Vercel Eve Review: Filesystem-First Agent Framework Tested

Ever stared at an Agent project with tools scattered across five files, prompts buried in environment variables, and no clear answer to “where does this thing even run from?”

Yeah, me too. That’s been the state of Agent development for the past year — powerful frameworks, zero conventions.

Then Vercel dropped eve three days ago, and the repo hit 1,358 stars before I’d even finished my morning coffee.

So I installed it, pushed it around for an afternoon, and here’s what I found: eve treats the filesystem as the agent’s authoring interface. Your agent lives in a directory structure — agent/instructions.md, agent/tools/, agent/skills/, agent/channels/, agent/schedules/. Write files, not boilerplate. The framework discovers them and wires them up automatically.

But is this the missing convention the Agent ecosystem needed? Or just another well-branded experiment from Vercel?

Honestly? I think it’s both — and that’s exactly why it’s worth your attention.

TL;DR — The Short Version

If you’ve ever wished an Agent framework would just get out of your way and let you write tools as TypeScript files in a directory — eve is that. But it’s not ready for production workloads. More on that later.

What Makes eve Different?

Every Agent framework I’ve used before eve asks you to write code. Lots of it. LangChain makes you chain abstractions. Vercel’s own AI SDK asks you to wire streaming into React components. They’re powerful, sure — but they’re library-shaped tools. You import, configure, compose.

eve flips the model: the directory is your API.

So here’s what npx eve@latest init my-agent gives you:

my-agent/
├── agent/
│   ├── instructions.md       # Your system prompt
│   ├── agent.ts              # Model config (Claude, GPT, etc.)
│   ├── tools/                # One file per tool function
│   │   └── search.ts
│   ├── skills/               # Reusable prompt + tool packs
│   ├── channels/             # Where your agent listens
│   │   └── terminal.ts       # Interactive terminal channel
│   └── schedules/            # Cron-like agent tasks
├── package.json
└── tsconfig.json

I opened this structure and pretty much knew how to write a tool without reading docs. Drop a .ts file with an exported function and a Zod schema into agent/tools/ — eve discovers it on next run. Write a system prompt in instructions.md — that’s what the agent sees. Add a channel file — your agent talks there.

And this is not a small UX win. This is the difference between “I need to learn a framework” and “I already know how to use this because I’ve used a directory before.”

Hands-On: I Built a Search Agent in 10 Minutes

I tested this on my Ryzen 9 workstation running Node 22. So here’s the exact sequence:

npx eve@latest init search-agent
cd search-agent

And that created the directory structure above. I opened agent/instructions.md and wrote:

You are a web research agent. You search the web, summarize results,
and save findings to files in the /output directory. Be concise.

Then I wrote my first tool in agent/tools/search.ts:

import { z } from 'zod';

export const schema = z.object({
  query: z.string().describe('The search query'),
  count: z.number().default(5),
});

export async function run({ query, count }: z.infer<typeof schema>) {
  const res = await fetch(`https://api.example.com/search?q=${encodeURIComponent(query)}&limit=${count}`);
  return res.json();
}

Then npm run dev — and the terminal channel fired up. I typed “latest AI agent frameworks 2026” and watched eve call my tool, process the response, and continue the conversation.

Total time from zero to running agent: about 10 minutes. No config files to edit, no middleware to wire, no provider abstraction layer to learn.

But here’s what surprised me: the framework doesn’t force you into its tool-calling format. And eve uses Zod schemas for validation but the run function is just a function. You can call APIs, read files, spawn processes — whatever TypeScript can do, your tool can do.

The Filesystem Paradigm — Why It Matters

The strongest idea in eve is something I’d call architecture by convention.

Now, in traditional frameworks, your agent’s architecture is implicit — it lives in how you compose classes and chain calls. New team members have to reverse-engineer the code to understand what the agent can do.

But in eve, the architecture is a directory listing.

• Want to know what tools your agent has? ls agent/tools/
• Want to add Slack support? Create agent/channels/slack.ts
• Want the agent to run a weekly report? agent/schedules/weekly-report.ts

This is the same insight that made Rails and Laravel successful: convention over configuration raises the floor for everyone. So junior devs produce maintainable code because the framework expects it that way.

Feature Comparison — eve vs the Field

I also wrote about ECC Agent Harness OS before — that’s the runtime layer for running agents at scale. Eve is the build layer. So they complement each other: build your agent with eve’s directory conventions, run it with ECC’s harness.

And then there’s PilotDeck Agent OS which sits at the infrastructure level — deploying and orchestrating agent fleets. Together these three tools form a pretty complete stack: eve → build → ECC → run → PilotDeck → deploy.

Where Eve Falls Short — Beta Reality Check

So let me be honest about the rough edges I hit.

The community is tiny. 82 forks. The GitHub issues list is sparse. So if you hit a problem, you’re mostly on your own right now.

Channel plugins are limited. Now the terminal channel works great. But custom channels require implementing a TypeScript interface. I tried building a simple filesystem-watch channel (agent reacts when a file changes) and found the channel API documentation thin.

No built-in persistence. Eve doesn’t save agent state between restarts. So your agent loses its conversation memory every time you stop npm run dev. But for a framework calling itself “filesystem-first,” I expected a file-backed memory system out of the box. So that’s the biggest gap for someone building anything serious.

Beta performance. I noticed slight latency on tool dispatch with more than 5 tools registered. Nothing critical, but worth noting — and the internal discovery loop re-scans the directory on each tool call.

Still, these aren’t dealbreakers for an experiment or a proof-of-concept. But Vercel’s own docs say “Public Beta” and they mean it. So don’t build your production pipeline on it today.

Who Should Use Eve Right Now?

Yes, if you:

• Want to prototype an agent idea in under 30 minutes
• Are evaluating filesystem-first architecture patterns
• Build with TypeScript and know Zod
• Want to teach agent development concepts with a transparent structure

Not yet, if you:

• Need production reliability or SLAs
• Are building a multi-agent system with complex memory requirements
• Prefer a framework with an established community and Stack Overflow presence

The Bottom Line

So eve is Vercel’s bet that the next generation of Agent tooling is about convention, not complexity. The filesystem-first approach is genuinely refreshing — I haven’t felt this “oh, I get it” moment since the early days of Next.js.

But it’s Beta software. So treat it as a design preview, not a deployment target.

If you want to see where Agent frameworks are heading — install it, build a toy agent, and feel the difference. Then use ECC Agent Harness OS for the runtime layer and PilotDeck Agent OS for deployment when you’re ready to go further.