Doing more with less
Frontier-level agent performance comes from how the run is structured, not from how big the model is. Prism on the open DeepSeek V4 Flash matches agents built on the largest proprietary models at 14–32× less cost — and the architecture explains why.
Frontier agents run the biggest models money can buy. We ran DeepSeek V4 Flash through our harness on the hardest public benchmark for AI code comprehension and landed beside them: 80.3% average pass@1, #5 of 17 systems, at $0.37 per task.
The four systems above it cost between $5.07 and $11.75 per task. DeepSeek V4 Pro — the larger model in the same family, running in Claude Code — scored 67.8%.
The delta is not the model. The delta is the run structure.
The bigger-model treadmill
When an agent fails on a long task, the default answer is a bigger model and a bigger context window. It is the obvious answer, and it is the expensive one. It also does not fix the actual failure mode.
A larger context window does not stop an agent from forgetting what it decided ten steps ago. A more capable model does not prevent it from drifting off-plan when the plan was wrong. A bigger parameter count does not help it pick work back up after an interruption. These are not reasoning failures. They are structure failures — and throwing more model at them is like fixing a broken steering column with a faster engine.
The industry has spent two years scaling models. The models are extraordinary. But the ceiling on what an agent can sustain is not set by the model. It is set by the architecture that surrounds it.
Short-horizon autonomy is a feature. Long-horizon autonomy is a category. The category is won on structure, not scale.
What actually breaks on long horizons
Before we talk about what works, we need to name what breaks. Every team running agents on real work has seen the same three failure modes:
Drift. The agent starts with a plan, but after a few dozen steps the plan is stale. The agent does not notice. It keeps executing against assumptions that stopped being true an hour ago, and the output quietly diverges from the objective.
Forgetting. The agent made a decision at step 12 that step 47 depends on. But step 47 cannot see step 12's reasoning — it only sees the last few thousand tokens of prompt history. The decision is lost, the context is gone, and the agent makes a contradictory choice without knowing it.
Collapse. Something fails — a tool call, a test, an assumption. A short-lived agent restarts from zero, losing every intermediate result. A human has to re-aim it, re-establish context, and hope the same thing does not happen again in ten minutes.
These are not edge cases. They are the default outcome on any task that runs longer than a few minutes. And none of them are fixed by a bigger model.
How we build agents instead
Coresource's Prism harness addresses these failures with three architectural mechanisms. Each one converts something a giant model brute-forces into something a small model plus structure handles cleanly.
Break the problem down
An objective is not a prompt. It is decomposed into milestones, steps, and execution waves before the agent acts. The model never faces the whole problem at once. It faces the next step with exactly the context that step needs — the relevant slice of the plan, the relevant evidence, the relevant state.
This is not prompt engineering. It is run engineering: the decomposition is a first-class artifact the runtime maintains and revises. When the plan is wrong, the agent re-plans. When a step fails, only that step's slice is invalidated. The rest of the run holds.
A focused slice of a coherent plan is a task a small model handles well. An unbounded scroll of prompt history is not.
Persistent memory
The agent does not rely on the model's context window to remember what happened. A single authoritative world-model holds intent, state, evidence, and decisions outside the prompt. Every step reads from a focused, relevant slice of that model rather than a scramble of accumulated chat history.
This is what keeps step 200 coherent with step 2. The decision made at step 12 is still there — not because the model remembered it, but because the runtime never forgot it. The world-model is the memory. The model is the reasoner. Separating them means the reasoner can be smaller without losing coherence.
Memory is a runtime property, not a model property. Build it into the architecture and the model size stops mattering for coherence.
Recovery loops
Failure is a routine event the runtime absorbs. When a step fails, the harness re-derives only the invalidated slice — the rest of the run holds its state. When reality diverges from the plan, the agent re-plans mid-flight rather than waiting for a human to notice. When work is complete, the agent verifies against the objective before calling anything done.
In one real run, the agent logged 201 revision-ledger entries across 47 step attempts. That is not the system failing. That is the system steering — the same thing a human engineer does all day, and the same thing an agent that needs you to re-aim it cannot.
Surgical recovery, not restart. Re-plan, not stall. Verify, not assume.
Why this makes small models punch up
Each of these mechanisms converts a brute-force requirement into a structural one.
A giant model needs to hold the entire plan in its context window and hope it stays coherent. A structured run gives a small model one step at a time, with exactly the context that step needs.
A giant model needs to remember every decision implicitly, buried in prompt history. A structured run stores decisions in a world-model and retrieves them on demand.
A giant model needs to power through failures with raw capability. A structured run recovers surgically and re-plans — the model only has to handle the narrow slice that actually broke.
Structure is what makes a smaller model reason like a bigger one. Every answer draws on many parts of the world-model at once: state, evidence, and how they connect. Because that context stays coherent instead of scattered, a smaller model sees the whole situation and reasons like a far larger one.
The evidence
The SWE-Atlas-QnA benchmark tests AI code comprehension across 124 tasks. It is the hardest public benchmark of its kind. Seventeen systems are ranked on average pass@1.
Prism on the open DeepSeek V4 Flash scored 80.3% at a measured cost of $0.37 per task. It ranked #5 of 17, matching agents built on the largest proprietary models.
Then look at DeepSeek V4 Pro — the larger model in the same family, running in Claude Code. It scored 67.8% at $0.27 per task. Prism puts the smaller Flash 12.5 points above the bigger model. The harness adds more performance than stepping up a model tier.
The top four systems cost 14 to 32 times more per task. A full benchmark run on Prism costs approximately $46. The task resolve rate is 29.0% — ahead of DeepSeek V4 Pro on Claude Code.
The economics that matter
"Doing more with less" is not a cost trick. It is what makes agents viable at scale.
A system that costs $11.75 per task is a research artifact. A system that delivers the same answer quality at $0.37 per task is a production capability — something you can run hundreds of times a day without the economics breaking.
The difference is not that we found a cheaper model. The difference is that we built a harness that makes a small model reason at frontier level. The cost savings are a consequence of the architecture, not the goal of it. The goal is coherence across hours of work. The economics follow.
Frontier-grade results, without frontier-grade cost.
Get early access
Coresource is moving into the hands of a first set of teams now.
We're also hiring the engineers and researchers who want to build the long-horizon era. If that's you, come build it with us.