An IT services company in Serbia just posted a vacancy for a Senior Software Engineer in AI systems performance. The job is to take large language models, spread them across racks of GPUs, and make the benchmark numbers look like a marketing slide instead of a confession. The irony is dense enough to dent a heatsink: this is a role about making AI efficient, and it is a role AI is about to make efficient.
What the role really is
Strip away the recruiter prose and the JD is a checklist of performance engineering applied to distributed inference:
- Distributed enablement and benchmarking: take a model, shard it across multi-GPU, multi-node clusters, run it, measure throughput, latency, and accuracy, log everything.
- Scalable systems optimization: tune the same workload across scale-up (more GPUs in one box) and scale-out (more boxes).
- Cross-team collaboration: work with the internal GPU library team to squeeze distributed workloads.
- Parallelization strategy: pick tensor parallel vs pipeline parallel vs expert parallel vs data parallel, per model, per topology.
- Model infra and management: maintain a model zoo, monitoring frameworks, benchmarking pipelines, dashboards.
- Performance monitoring and visualization: real-time dashboards reporting perf, accuracy, and reliability to internal stakeholders and external users.
Mandatory skills: vLLM, SGLang, Llama.cpp, KV cache transfer mechanics, expert parallelism. C++ and Python. Quality assurance, benchmarking, automation.
That is not a job description. That is a build spec for an autonomous benchmarking agent.
How AI takes this role
Here is the pipeline that replaces most of it, built from parts that already exist.
Step one: the benchmarking loop
The biggest chunk of this job is running models across configurations and measuring what happens. That is a loop with a fixed shape: pick a model, pick a topology, pick a parallelism strategy, launch, collect metrics, compare. An LLM agent with tool access to a cluster scheduler — Slurm, Kubernetes, whatever the lab runs — generates that loop. It reads the model zoo, enumerates configurations, writes the launch scripts, submits the jobs, polls for completion, and ingests the results. The specialists currently doing this by hand are writing Python glue that a code model writes in seconds. The bottleneck is not the code. It is cluster queue time, and no human fixes that.
Step two: the parallelism picker
The interesting part of the job — choosing tensor parallel vs pipeline parallel vs expert parallel for a given model on a given topology — is a constrained optimization problem with a measurable objective. Research tools already exist that profile a model's compute and memory characteristics and recommend a sharding plan. Wire that into the benchmarking loop and you get an agent that proposes a strategy, runs it, measures it, and either keeps it or tries the next one. The human today does maybe ten of these experiments a week. An agent does ten before lunch, and it does not forget which one won.
Step three: the dashboarding
Real-time dashboards reporting performance, accuracy, and reliability metrics. This is the easiest part to automate because it is already the most automated part of any mature engineering org. Metrics go into a timeseries store, Grafana renders them, alerts fire on thresholds. The human contribution here is deciding which metrics matter — and that is a question you answer once, encode in config, and then the dashboard maintains itself. An agent that watches the benchmarking output and updates the dashboard schema when new metrics appear is a weekend project, not a headcount.
Step four: the report
The part where the engineer walks into a room and explains to stakeholders why model X is twelve percent slower on the new topology. An LLM that has the benchmark results, the git diff, and the prior baseline writes that report. It can even write the slide. The human used to add the insight — "the KV cache transfer is bottlenecked on inter-node bandwidth because we're doing expert parallel across nodes with no locality awareness" — but an LLM staring at the same traces generates that sentence too, because the trace says so. The insight was never magic. It was just reading.
The tools, specifically
Not hypothetical. The stack that eats this role:
- Code generation: a strong coding model for the Python glue and the C++ profiling harnesses. The boilerplate around benchmarking — argument parsing, config loading, result serialization, metric aggregation — is exactly the kind of thing these models write cleanly.
- vLLM / SGLang / Llama.cpp: the frameworks the JD lists as required skills are the frameworks the agent calls. It does not need to understand them the way a human does. It needs to invoke them with the right flags, read the logs, and adjust. That is API-level work.
- Cluster orchestration: Slurm or Kubernetes, same as the human uses. The agent just submits jobs faster and does not take coffee breaks between submissions.
- Profiling and tracing: the tools already exist. The agent reads the same traces a human reads. The difference is the agent reads all of them, every time, without skimming.
- The optimization layer: this is the piece closest to research, and it is where the agent goes from automation to replacement. Give it a budget of cluster hours and a target metric and let it search the strategy space. It is grid search with taste. Humans do grid search without taste and call it experience.
Where it breaks
Here is where it breaks.
Silicon-level debugging. When the workload is slow because the GPU memory controller is doing something weird with a specific tensor layout on a specific revision of the hardware, the agent hits a wall. That is a problem that requires staring at PTX assembly, reading hardware errata, and talking to the chip designers. The agent can profile it. It cannot always explain it. Not yet.
The library team conversation. "Cross-team collaboration" in the JD means walking over to the GPU library team and saying "your kernel is suboptimal for this access pattern, here's why, fix it or let us work around it." That is a negotiation between humans who share context the agent does not have. The agent can file the issue with the profile attached. It cannot do the hallway conversation that turns a six-week fix into a two-day one.
Novel architecture. When a new model architecture shows up that does not fit any existing parallelism template, someone has to think about it from first principles. The agent's strategy space is defined by what it has seen. A genuinely novel tensor parallelism scheme for a mixture-of-experts model with a weird routing topology is still a human's job, for now.
The stakeholder trust problem. External users and internal stakeholders want to hear from a person that the numbers are real. The agent can generate the report. It cannot stand in front of the infrastructure team and answer "are you sure?" for forty minutes. That is theater, but it is the kind of theater that comes with a support contract.
So the role does not vanish. It compresses. One engineer with the agent stack does what five did last year. The other four are the ones the vacancy is trying to hire between.
The real joke
The company that makes the chips is hiring a person to make the models run fast on the chips. That person's job is to write automation and benchmarks and pipelines. The automation and benchmarks and pipelines are the exact thing an agent writes best. They are asking for a human to build the system that makes the human optional.
The JD says "passion for automation in the AI/ML space." Read it again. They are not asking you to automate the workload. They are asking you to automate yourself, and they are calling it passion.
The vacancy is not a forecast. It is a receipt. The role is already being eaten, and the posting is the last place it is allowed to be a job title. What hiring signals show is not where the work is going. It is where the work already went.
Apply if you want. Just know what you are building — and know that the moment the pipeline runs clean, the company has no reason to keep you.

