Eve makes agents legible. It doesn't make them accountable.

Vercel introduced Eve with a line that will probably stick: like Next.js, for agents. It's a good analogy, and a revealing one. Next.js didn't win because React developers couldn't build routes, render pages, or deploy apps before it existed. They could. But every serious team had to assemble the same pieces from scratch — routing, rendering, bundling, API handlers, caching, data loading, error handling — all the conventions that turn a pile of components into a production application. Next.js made the web app legible. A folder became a route. A file had meaning. A project had a recognizable shape.

Eve is trying to do the same for agents. Before Eve, every team rebuilt the same agent plumbing — state, tool wiring, sandboxing, approvals, memory, logging, evals, channels, scheduling — before their agent could do anything useful, and none of it carried cleanly to the next agent. Eve makes the agent a directory of files and ships the production machinery with the framework: durable execution, sandboxed compute, human-in-the-loop approvals, tracing, evals, subagents, channels, schedules, and secure connections. The work moves from assembling infrastructure to defining behavior. That's a real shift — it's why I just moved Vercel out of the Partial column in the Managed Agent Platforms map. But it also exposes the next problem.

When building an agent becomes easy, the scarce thing is no longer the build. The scarce thing becomes the ability to say, with confidence:

This is what the agent was allowed to do. This is what it actually did. This is who authorized it. This is what evidence it used. And this is why a client, auditor, brand, or regulator should trust the result.

An agent is now a directory

Eve's central move: an agent has a shape, and that shape is a folder.

Each file or folder carries part of the agent's identity. The agent stops being a custom runtime hidden in application code and becomes a readable object — you can inspect it, diff it, review it, version it.

This is the Next.js moment. In Next.js, a folder is a route and a file is a page because the framework owns the routing. In Eve, a file is a capability, a rule, a skill, a channel, a schedule, or a delegated agent because the framework owns the agent loop. You add a tool by adding a file; you add autonomy by adding a schedule. For the first time, the structure of the agent starts to resemble the structure of the accountability problem.

From black box to glass box

A trace is a flight recorder. It is not yet a certificate.

Most agent stacks are black boxes with a chat interface attached. The user sees an answer; the engineer sees logs; the business sees risk; the auditor sees a problem. Eve turns that black box into something closer to a glass box — identity visible in instructions.md, capabilities in tools/, knowledge in skills/, delegation in subagents/. And at runtime it gives every run a spine: durable execution, checkpoints, traces, approvals, tool calls, sandbox commands, evals.

A traditional log is a diary — it tells you something happened, after the fact, in fragments. A trace is a flight recorder: it shows the sequence — what the agent loaded, what it called, what it asked a human to approve, what it did next. For debugging, that's useful. For trust, it's only the beginning. A flight recorder tells you what the aircraft did. It does not, by itself, certify that the flight was authorized, compliant, safe, on-brand, or acceptable to the passenger.

Legibility is not trust

A trace is evidence. It is not yet an attestation.

This is the central gap. Eve answers what did the agent do? It does not fully answer: was it allowed to? Was the source acceptable? Was the action within the user's intent? Was the result on-brand? Was the human approval meaningful? Was the delegated work still inside the trust boundary? Can this be handed to a client, compliance team, or regulator as a defensible record? A span tree can show that an agent ran a SQL query and posted a number. It does not prove which metric definition applied, whose authority it acted under, or whether the organization can stand behind it. That distance — from evidence to attestation — is the same gap I mapped in Can I Prove What the Agent Did?, and it's where AUX lives.

AUX is not another agent framework. It's the experience, authorship, and trust layer above the framework. If Eve is the agent's skeleton, AUX is the social contract around the agent. If Eve makes agents easy to build, AUX asks whether anyone should trust them enough to let them work — because, as I've argued in A Safe Agent Isn't a Trusted One, agentic products aren't just interfaces. They're relationships, and a system with memory, initiative, and judgment behaves less like a tool and more like a collaborator. Collaborators need boundaries, escalation paths, recoverability, and trust that compounds over time.

The clean division

Eve defines the agent. AUX defines the relationship.

Eve creates the substrate; AUX defines the trust architecture on top of it. Four places where the framework hands off to the discipline:

A single agent can be reviewed as a worker. A swarm has to be reviewed as an organization — and the more multi-agent systems become normal, the more that matters.

The Next.js analogy has a second half

Next.js didn't eliminate product design. It made it more important.

Once every team could build fast React apps with the same conventions, the differentiator moved up the stack: experience, performance, brand, distribution, trust. The same thing is about to happen with agents. The runtime will standardize; the scaffolding becomes table stakes. That doesn't make the market softer — it makes it harder. When everyone can ship an agent, “we built an agent” stops being interesting, and the buyer's question becomes: can I trust it with my data, my customer, my brand, with a process that used to require judgment — and can I prove what happened when something goes wrong? That is exactly the movement from UX to AUX.

The buyer will not buy the trace

A CTO cares that Eve emits traces. The buyer buys confidence.

A developer cares that the tool call is inspectable; a platform team cares that sessions are durable. But the buyer doesn't buy a trace — they buy confidence, and what that means is specific to who's buying. This is why buyer-side evaluation, like the Agent Buyer's Map, checks the things the market will actually demand before an agent goes near real work — not just the things the builder decided to test.

An agent can pass technical evals and still fail the buyer's trust threshold. It can answer correctly but feel uncontrollable; be safe but not understandable; be observable but not accountable. AUX is the work of closing that gap.

The stack is separating

Five layers — and Eve owns the bottom two.

Eve makes the separation clearer. The runtime layer is getting better fast, which is good news: it means the trust layer can stop arguing about whether agents are possible and start binding to real primitives — traces, approvals, skills, tools, channels, schedules, subagents, evals, durable runs.

In open-trust-stack terms, Eve is one runtime that can emit provenance signals. AUX is the authorship-and-accountability control profile that can sit above any runtime that emits them — and that distinction matters, because the future won't be one framework. There will be Eve agents, LangGraph agents, CrewAI agents, Microsoft agents, Salesforce agents, and agents hidden inside SaaS products. The trust layer can't be locked to one runtime; it has to work across them. It's the same separation I drew in the two-layer stack, and the harness it runs on is TrustKit.

Why this lands now

When the build becomes a weekend, the competition becomes trust.

When building an agent took a quarter of engineering, the scarce thing was the build. Now the build is becoming a weekend — and that changes the market. The first wave of agent companies competed on capability: look what the agent can do. The next wave competes on trust: look what the agent can be trusted to do, for whom, under what authority, with what evidence, and with what recovery path.

Frameworks like Eve aren't competitors to the trust layer. They're accelerants for it. They make agents cheaper to create, behavior easier to inspect, approvals easier to insert, traces easier to capture, subagents easier to compose — and by doing all of that, they make the accountability gap impossible to ignore. The more agents you can create, the more urgently you need to answer which ones are allowed to act, which can speak for you, which can touch customer data, and which can be defended after the fact. That's not a framework question. That's an AUX question.

---