The Agent Narrative Is a Liability

“AI agents will replace your entire workflow.” “Autonomous coding agents that ship features while you sleep.” This framing is actively harmful. It burns credibility and obscures what actually delivers: deterministic guardrails around LLMs, not autonomous decision loops.

Here’s what actually works: wrapping a token-streaming binary with deterministic systems that provide sources of truth. A sandbox runtime that catches errors before you see them. A structured output pipeline that validates before it commits. A retry mechanism that knows when to stop. This is not an agent. This is a harness.

What v0 Actually Is

Take v0 by Vercel. The marketing calls it an “AI agent.” The implementation tells a different story.

When you prompt v0 to build a dashboard, here’s what actually happens:

1. Your prompt is parsed for intent and constraints — not by an LLM deciding what you meant, but by a routing layer that selects the appropriate model and context.

2. A composite model generates code — multiple specialized models contribute, with a retrieval system pulling relevant documentation and an autofixer layer that catches and resolves errors before output reaches you.

3. The output runs in a sandbox — a deterministic environment where the generated code is tested before you ever see it. This is not an LLM “deciding” if the code works. It’s a runtime saying yes or no.

4. GitHub sync pushes to a branch — deterministic output path. The code goes to a version-controlled location with a pull request workflow. You review before it merges. Nothing autonomous about it.

Every step of this pipeline constrains the LLM rather than letting it run free. That’s the harness pattern. The LLM is a component, not a decision-maker.

Agents vs Harnesses: The Architecture

An agent is an LLM in a while loop with a prompt. A harness is a deterministic system that uses an LLM as one of many components — alongside validation, sandboxing, retry logic, and human gates.

Why Agents Fail in Production

The fundamental problem is nondeterminism. Large language models are probabilistic systems. Ask the same question twice, you might get two different answers. Run the same agent loop twice, you might get two different outcomes — one that works, one that silently corrupts data.

You can test a harness. You can run a million prompts against it, measure the validation pass rate, tune the retry logic, tighten the output schema. You can still never guarantee correctness — that’s the nature of probabilistic systems. But you can measure your failure rate and build gates that catch failures before they cause damage.

You cannot test an agent the same way. An agent that “decides” to call an API, then “decides” the response was wrong, then “decides” to try a different approach — that’s an exponentially large state space. You can’t validate every path. You can’t predict every failure mode. You’re not engineering a system; you’re hoping an LLM gets it right.

This is not a theoretical concern. Developers who’ve deployed agent loops report the same patterns: credit burn from infinite retry spirals, hallucinated API calls that corrupt state, “autonomous” agents that require more supervision than writing the code yourself. The demos are impressive. The production behavior is not.

The Engineering Mindset

Building a good harness requires thinking like an engineer, not a futurist:

Assume nothing. The LLM will hallucinate. It will generate broken imports. It will confidently output incorrect code. Your harness must catch all of this before it reaches production.

Test continuously. Run validation suites against every change to your system prompt, every model upgrade, every pipeline modification. The output will shift in ways you didn’t predict. Measure what breaks.

Constraint is the product. The value of a harness is not the LLM — it’s the guardrails. The sandbox that catches errors. The schema that enforces valid JSON. The retry logic that knows when to stop. These are the features your users actually depend on.

LLMs are autocomplete — and that’s enough. A language model predicts tokens. Wrapping it with sources of truth (schemas, tests, deterministic validation) turns token prediction into useful output. It doesn’t need to be AGI. It doesn’t need to reason. It needs to follow instructions, and the harness needs to verify that it did.

What This Means for v0

v0 works because Vercel’s engineering team understood this distinction. They didn’t build an autonomous coding agent. They built:

• A composite model family that routes to specialized models based on the task — not an LLM choosing which LLM to use
• A sandbox runtime that tests generated code before you see it — deterministic pass/fail, not LLM self-evaluation
• An autofixer that catches and resolves errors — structured retry logic with limits, not infinite loops
• GitHub sync that pushes to branches — version-controlled, reviewable, reversible

Every one of these is a deterministic system. The LLM generates text. Everything else is engineering.

When v0’s composite model family achieves a 93.87% error-free output rate, that’s not because the LLM is “smarter.” It’s because the harness catches the other 6.13% before it reaches you.

Mohamed Ali Lamkadmi is a systems programmer and harness developer. He builds infrastructure for deterministic LLM-based systems. Find him on GitHub.