Everyone can get an agent to work once. The hard part — the part that decides whether you have a product or a party trick — is getting it to work the hundredth time, on a task that takes hours, with money or code on the line. That discipline has a name now: agentic engineering. It is much less about prompts and much more about reliability, governance, and the loop the model runs inside.

The long-horizon cliff

Agents are improving fast on length: METR finds the task duration an agent can complete at 50% reliability has roughly doubled every seven months for six years. But the same data shows the cliff: near-100% success on tasks that take a human under four minutes, and under 10% on tasks that take more than four hours.

Why does it fall off so sharply? Toby Ord's analysis models it as a near-constant per-minute failure rate: a long task chains many interdependent steps, and one bad step sinks the run, so success decays exponentially with length. Every agent has a "half-life." Make the task twice as long and you don't lose a little accuracy — you fall off a curve.

Why averages lie

It gets worse when you measure honestly. τ-bench introduced pass^k — does the agent succeed on the same task across k independent tries? State-of-the-art function-calling agents succeed on under half of tasks and are wildly inconsistent: even when average single-run success looks like 50–60%, pass^8 can fall below 25%. A reliability-science framing makes the point general — as horizons grow, pass@1 systematically hides deployment-critical risk.

If you ship on the strength of a single good run, you are shipping a coin flip and calling it a feature.

Self-correction isn't enough

The tempting fix is "just have the agent check its own work." The evidence says that alone doesn't hold: DeepMind found LLMs largely cannot reliably self-correct reasoning without external feedback — and sometimes get worse after trying. What does work is iteration grounded in a real signal: Self-Refine (generate → feedback → refine, repeated) lifts task performance by ~20% absolute when the feedback is concrete. The lesson isn't "let the model reflect." It's "give the loop a verifier."

What we build instead

That is the whole thesis behind Cortex. An agent shouldn't free-run; it should sit inside a control loop that validates every step against real checks — tests, lint, policy, acceptance criteria — and repairs on failure until nothing changes. We can prove that loop converges to a stable, correct result (a least fixed point), and our benchmark shows the same base model gets safer and more capable once it's inside it.

the loop, distilledwhile (true) {
  const step   = agent.next(task, state)   // model proposes
  const gated  = policy.admit(step)        // capability + approval gate
  const report = verify(gated, task.checks)// real signal, not self-reflection
  if (report.allPass) return commit(state)// fixed point — provably done
  state = repair(state, report.failures)   // targeted, not a redo
}

Two more lessons from the field shape how we orchestrate. Anthropic's multi-agent research system used ~15× the tokens of a chat but beat single-agent by 90% — orchestration pays, at a cost you should choose deliberately. And their guidance on building effective agents is blunt: prefer simple, composable patterns, and add autonomy only when it measurably helps. Governance is what lets you add that autonomy without losing the plot — capabilities an agent can't exceed, approvals on the risky moves, an audit for everything.

Agentic engineering, in one line: stop trying to make the model perfect, and start engineering the system that catches it when it isn't.