The leap from suggestion to agent is not a bigger model. It is a loop that can act, observe the result, and decide what to do next.
TL;DR
- Autocomplete predicts the next token; an agent runs a plan → act → observe → iterate loop.
- The agent's power comes from its tools and harness, not just the underlying model.
- The hard parts are verification and stopping conditions, not generation.
Autocomplete vs. agent
Last year's AI assistant was a very good autocomplete: you typed, it predicted the next lines, you accepted or rejected. The human closed every loop.
A coding agent closes its own loops. Given a goal, it plans steps, edits files, runs the tests or the build, reads the output, and decides whether it is done or needs another pass — often across dozens of steps without waiting for you between each one.
What is actually inside
Strip away the branding and a coding agent is four things working together:
- A model that reasons and generates.
- Tools it can call — read/write files, run a shell, search the codebase, query an API.
- A context strategy — what it knows about your project: instructions, conventions, relevant files.
- A loop that feeds tool results back in and decides the next action.
Goal ─▶ Plan ─▶ Act (edit / run a tool) ─▶ Observe result
▲ │
└──────────── Iterate ◀──────────┘
(until done or blocked)
When an agent fails, it is rarely the model "not being smart enough." It is usually a missing tool, weak context, or a loop with no good stopping condition.
Why the harness beats the model
Two teams using the identical model get wildly different results depending on what they wrap around it. A strong harness gives the agent:
- The right tools, scoped tightly — enough to do the job, not enough to do damage.
- Good context — your conventions, the relevant files, what "done" looks like.
- Guardrails — checks that block dangerous actions before they execute.
The model is the engine; the harness is the car. You can put a great engine in a car with no steering and it will still drive into a wall.
The genuinely hard part: knowing when to stop
Generation is largely solved. The unsolved problems are verification and termination: How does the agent know its change is correct? When should it stop iterating versus ask a human? The best setups give the agent a concrete feedback signal — a passing test suite, a type check, a linter — so "done" is something it can observe rather than guess.
What this means for you
Your leverage moves from writing code to designing the environment the agent works in: the tools it can call, the context it starts with, and the checks that tell it when it has succeeded. Build that well and the agent handles the mechanical 80%. Build it poorly and you spend your day cleaning up confident mistakes.
The agent is only as good as the loop you put it in.