Most enterprise LLM work stalls in the same place — not at capability, but at the point where a demo has to survive real operating conditions.
88%of agent pilots never reach production
<30%of deployed LLMs run reliably in production
70%name non-deterministic output as blocker #1
The blockers cited most are evaluation gaps, governance friction, and reliability — not model quality. That is the problem I work on.
CASE 01
Autonomous agent fleet: 250 merged PRs in three months
Client
AZN (azn.uz) — commercial and industrial equipment distributor, Uzbekistan. Published with the client’s permission.
Role
Architect and operator of the agent fleet — designed, built, and ran it solo
Period
June – August 2026
Problem
A commercial build with a real deadline and a small team. In the standard approach every ticket costs a developer's full attention from triage to merge — throughput is capped by headcount, and expensive people spend most of their time on mechanical work.
What I built
An autonomous SDLC fleet where coding agents own the pipeline end to end. Each stage is a separate agent with a narrow contract.
Every stage has one job and a narrow contract. The dependency gate verifies prerequisites against the codebase, not the tracker — a ticket marked done whose code never landed breaks everything downstream, quietly.
dispatcher — sweeps the tracker, picks only unblocked tickets, assigns a bounded batch
dependency gate — verifies every dependency is actually finished in the tracker and in the codebase; blocks with a comment when the foundation is missing
triage — judges difficulty from code-health signals; routes simple work straight to the executor, writes an implementation plan first for messy cross-cutting work
executor — implements on an isolated branch, conventional commits, opens the PR
code review — adversarial review against the originating ticket before a human sees it
PR watch — catches regressions appearing after the authoring agent finished: red CI from a moved base branch, new merge conflicts
merge reconcile — reconciles the board against GitHub reality so status stops lying
The interesting problem is not making an agent write code. It is keeping a fleet alive under failure. Most of the engineering went into the modes nobody demos:
Silent stalls — a sweep autopilot that quietly stopped firing, tickets stuck in-progress behind a dead agent, review backlogs piling up with no alert. Fixed with a watchdog that only observes and reports, never reassigns work itself.
Duplicate work — PR-watcher deduplication, so a flapping CI run does not reopen the same ticket five times.
Context bloat — agents pulling far more context than the task needed. Both a cost problem and a quality problem: a bloated context degrades the output.
Ordering hazards — dependency verification against the codebase rather than the board.
CASE 02
An LLM pipeline that cannot report success without doing the work
Type
Multi-tenant content pipeline serving three products
LLM pipelines lie about their own output. An agent asked whether it did the work says yes. Ask a second agent to check, and it agrees — because it was handed the same context that produced the error in the first place.
Correlated failure looks exactly like consensus.
What I built
An 11-stage pipeline where every stage has an explicit contract — input, work, output, gate — and no stage advances on a model's own say-so.
The four gates run in parallel because the artifact is frozen, all are read-only, and none consumes another's verdict. Any failure rewrites the file, which invalidates every hash-bound report downstream.
Four design decisions
Deterministic gates, not honor system. Gate A is a linter — 52 coded checks that pass or throw. Structure, evidence density, keyword thresholds, metadata bounds, brand discipline, competitor-link policy. No model is asked for an opinion on anything a script can decide.
Hash-bound reports. Every quality report carries the SHA-256 of the exact bytes it audited. Mutate the artifact and the report is invalid. This closes the hole where an agent emits a clean PASS 10/10 never tied to the shipped file — I found exactly that orphan-report path in my own system and closed it.
Adversarial gate with deliberate context starvation. Gate C receives the final artifact and the live web, and nothing of ours — not the topic, not the product profile, not the research notes, not the fact that other gates passed.
Gates run on what actually ships. An earlier version ran the linter on refined.html and fact-check on draft.html, while the file that shipped was final.html — which failed both. Every check green, none looking at the delivered artifact.
Results
Measured across production runs
Metric
Value
Factual claims machine-verified
265
Contradicted claims shipped
0
Unverified numbers, dates, names shipped
0
Independent sources fetched by the adversarial gate
22
Quality audit scores (hash-bound to shipped bytes)
8.5 / 8.5 / 8.6
The result that matters
On one run the adversarial gate found four defects that every other gate had passed — one serious. All four were internally consistent with our own notes, and contradicted the live product page.
Serious · sell
The article named two subsystems and then counted them as one item in a list — the product ships a single combined subsystem. A reader who clicked through would see the inconsistency.
Inconsistency
An architecture claim the linked page does not support: the article asserted a structural split that the published layout does not show.
Sleight-of-hand
A pricing comparison whose arithmetic was correct, but which measured the same workload two different ways — in our favor.
Omission
A caveat list that omitted the message TTL — the limit a practitioner would consider decisive.
Every one of these would have shipped under a conventional review setup. They were caught precisely because one checker was denied our context.
Gates that check output against your own notes are blind to any defect that entered the notes. They also never ask what is missing. Withholding context is not an oversight — it is the instrument.
Multi-tenant by construction
One pipeline serves three products. Zero hardcoded brand names, domains, or vocabulary in the linter — every product fact loads from a profile file. Adding a product is a config change, not a code change. Running without a profile fails loudly with an argument error, because a silent run would disable every brand gate at once.
WORK WITH ME
What I do
Evals and gates — deterministic verification where a script can decide, adversarial review where it cannot, and correlated-failure protection between them.
Agent reliability — the failure modes that only appear after week one: silent stalls, duplicated work, context bloat, orphaned state.
Multi-agent orchestration — contracts between stages, isolation where it earns its cost, parallelism where the artifact is frozen.
Full-stack delivery — I ship the system around the model layer, not just the model layer.
Production readiness audit — fixed price, 1–2 weeks
I review your LLM system and find where it degrades silently. You get the findings, a split of what a script can verify versus what needs adversarial review, a correlated-failure risk map, a prioritized gate and eval plan, and a walkthrough call.