For the last decade, the unit of AI work has been the turn. You ask a question; the model answers. The interaction is measured in seconds, and everything — context windows, latency budgets, billing — is shaped around that rhythm. It's a good fit for search, for chat, for autocomplete. It's a terrible fit for the kind of work that actually fills a person's week.
Real work has a horizon. Closing the books takes days. Migrating a codebase takes weeks. Drafting, reviewing, and revising a contract is a back-and-forth that spans people and time. When we started building Alverion's fleet, the goal wasn't a faster chatbot — it was an agent that could pick up a genuinely hard project and stay with it for hours, the way a capable colleague would. That single shift, from seconds to hours, changed almost every engineering decision we made.
The second-scale assumption
Turn-based systems quietly assume that the world holds still between your question and the answer. The context is whatever you pasted in; the state is whatever fits in the window; if anything goes wrong, a human is sitting right there to notice and retry. None of those assumptions survive contact with a six-hour task.
Over six hours, the world moves. Files change underneath you. A dependency you relied on at minute ten is gone by minute two hundred. The original instruction, perfectly clear at the start, turns out to be ambiguous in a corner you only reach an hour in. And critically — nobody is watching. The agent has to notice its own mistakes, because the human who would have caught them is asleep, or in a meeting, or simply trusts the system to get on with it.
What breaks at the hour scale
When we ran our first long jobs, the failures were not the ones we expected. The model was rarely "wrong" in the single-answer sense. Instead, things degraded slowly. A few patterns showed up again and again:
- Context decay. By hour three, the details that mattered at hour one had been crowded out. The agent was technically still working — just on a subtly different problem than the one it started with.
- Compounding drift. A small wrong assumption early on doesn't announce itself. It quietly shapes every later decision, so the run looks healthy right up until the result is unusable.
- Silent stalls. A flaky external call, a rate limit, a lock it couldn't acquire — and the agent would wait, politely and forever, with no human to nudge it.
- No clean recovery. When something did fail at minute 200, restarting from minute zero wasn't just slow — it threw away two hundred minutes of perfectly good work.
None of these are model-quality problems you can solve by swapping in a bigger model. They're systems problems. The intelligence was there; the scaffolding around it wasn't.
A long-horizon agent isn't a smarter chatbot. It's a system that has to remember, recover, and stay honest about its own progress without anyone watching. — from our internal design review, late 2025
Designing for long horizons
The fix wasn't a single clever trick. It was treating the run itself as a first-class object — something that has a plan, a memory, checkpoints, and a way to talk about its own health. Three principles ended up doing most of the work.
1. Make the plan explicit and revisable
Before the agent touches anything, it writes down what it intends to do and why. That plan isn't decoration — it's the thing every later step is checked against. When new information arrives that contradicts the plan, the agent revises the plan deliberately rather than silently drifting. The plan is the agent's defence against forgetting what it was actually asked to do.
2. Checkpoint everything
Long work has to be resumable. Every meaningful step writes a durable checkpoint, so a failure at minute 200 resumes from minute 195, not minute zero. This one change turned "the run failed" from a catastrophe into a hiccup — and made it safe to be ambitious about how long a single job could run.
3. Split, then reconcile
Some problems are too big for one agent to hold in its head, no matter how good. The fleet decomposes those into parallel sub-tasks, runs them concurrently, and then reconciles the results — catching the places where two agents reached incompatible conclusions before they reach you.
Long-horizon doesn't mean unsupervised in the legal sense. Every Alverion run is bounded by explicit permissions and leaves an auditable trail of what it did and why — so "the agent worked for six hours" never means "the agent did six hours of things you can't inspect."
Memory is the hard part
If there's one component that separates a long-horizon agent from a fast chatbot, it's memory. Not the context window — real, durable memory that persists across hours and sessions, knows what's worth keeping, and stays strictly scoped to the work and the customer it belongs to.
We landed on a layered model, and the boundaries between layers turned out to matter more than the cleverness of any single layer:
| Layer | Holds | Lifetime |
|---|---|---|
| Working | The current step's active context | Seconds to minutes |
| Run | The plan, checkpoints, decisions so far | The length of the job |
| Long-term | Durable facts about a project or org | Persistent, scoped, revocable |
Long-term memory is the one customers ask about most, and rightly so — it's also where sovereignty stops being abstract. That memory lives on EU-resident infrastructure, scoped to your organisation, and it never becomes training data. An agent that remembers your business is only an asset if you're certain that memory can't leak or wander.
Earning unattended trust
The last problem is the human one. People will happily let an agent answer a question. Letting it run for six hours while you're not looking is a different kind of trust, and you don't get it by asking. You earn it by being legible.
That means a run you can watch in real time if you want to, a complete record of what happened if you'd rather review it after, and honest reporting when the agent is uncertain or stuck — instead of a confident answer that papers over a problem. The most important feature of a long-running agent isn't how much it can do alone. It's how clearly it can show its work.
What this unlocks
When an agent can hold a plan, remember what matters, recover from failure, and stay legible for hours, the category of work it can take on changes completely. It stops being the thing you ask quick questions and becomes the thing you hand a project to on Friday and review on Monday.
That's the shift we care about: not saving someone thirty seconds on a search, but taking the long, mundane, multi-day work off their plate entirely — so the people you hired for judgment spend their week on judgment. If you want to see where that fits in your own organisation, our guide to bringing AI into your company is the place to start.