Every agent platform can show you a trace now. Spans, tool calls, token counts, a waterfall of what the agent did and how long it took. Two years ago that was a product. Today it is a checkbox — a primitive that hyperscalers and open-source projects alike hand out for free.
So watching agents is no longer the job. The job is making them better, run after run, without asking a firm to surrender the two things it cannot give up: control of where its work runs, and custody of its clients' data.
Those are the two bets underneath Phoenix. Neutral by default. Better every run. This is why they are the same bet.
Continual learning is a loop, not a feature
"Continual learning" gets used as a synonym for "we have a dashboard." It shouldn't. A dashboard tells you an agent got 7% worse on a client's task last week. It doesn't fix it.
The thing worth building is a loop: evaluate a run in place, catch the failure, hand a coding agent the concrete fix, re-run the exact case that failed, and merge only when the score comes back green. Every cycle, the agent a firm delivers to its client gets measurably better — and that improvement, not another chart, is what keeps the client.
Most eval tools have this backwards. They ask you to author datasets, write scorers, and design experiments before you see a single result — a research project you have to finish before the tool earns its keep. The loop should run the other way. Evals should grow out of the failures you actually spot in production, not out of a synthetic suite you wrote on day one. You find a bad run, you turn it into a test, and the test guards every future version. The work compounds instead of front-loading.
Neutrality isn't a preference. It's the job.
A firm that delivers agents to clients does not get to choose the client's cloud, and often doesn't get to choose the model. A bank mandates its own VPC. A law firm mandates zero retention. A healthcare client mandates a region. The infrastructure that runs the agent has to run wherever the client says — any model, any harness, on any cloud, on-prem, or the client's own boundary.
That makes lock-in disqualifying, not merely inconvenient. An agent cloud welded to a single hyperscaler can serve the clients who happen to live on that hyperscaler and no one else. Neutrality is what lets one firm serve a book of clients that each drew a different line.
It's worth being precise about what "neutral" means here, because the word gets stretched. The frameworks — LangGraph, CrewAI, the coding CLIs — are things the runtime runs, not things it competes with. Model choice is the client's, not the platform's. The only opinion the infrastructure should hold is that it holds no opinion about any of these.
You can't improve what you're not allowed to keep
Here is where the two bets collapse into one.
To improve an agent, you have to evaluate its runs. To evaluate a run, something has to see the run. The observability vendors solve this the obvious way: they ingest the trace and store it on their servers, because they have to keep it to score it. That is exactly the thing a serious client forbids. "Every law firm contract requires zero data retention," as Harvey put it when it explained why it built its own runtime rather than lease one — the data cannot sit on a third party's servers.
The way out is to evaluate in place. Because the runtime owns execution, it can score the run in the same isolated session that produced it, keep only the derived signal — the score, the structure, the attribution — and purge the content when the session ends. No prompts, no outputs, nothing to leak. Zero retention by default, and continual learning anyway.
A vendor that only watches from the outside cannot do this. It doesn't own execution, so it can't evaluate in place, so it can't offer real zero-retention. Owning the runtime is the unlock for both improvement and privacy at once. That is not a coincidence; it is the whole architecture.
Why now
The timing isn't a guess. Teams are drowning in traces they can't act on — a large share run no evals at all and say their tooling is disconnected from production. The observability layer is consolidating, which is what happens to a category once it becomes a primitive. And the firms with the most to lose are voting with their engineering budgets: when buying didn't fit, Harvey built its own neutral, zero-retention, multi-model runtime rather than lock to a cloud.
The value is moving off the dashboard and onto the two things a dashboard can't do: run the agent anywhere, and make it better without keeping what it saw.
What we're building
Phoenix is the neutral runtime where agents prove and improve. It runs any harness unmodified, on any cloud or the client's own VPC, isolated per client and retaining nothing by default. It evaluates every run in place, turns the failures into the tests that guard the next version, and hands the firm an outcome it can put in front of its client.
Watching agents was the last era. Making them better — neutrally, and without keeping a byte you're not allowed to — is this one.
