Frontend

Vercel's Eve Framework Treats AI Agents as Standard Software Projects

By 猩猩程序员 · Jul 3, 2026

Read original on juejin.cn ↗ Google Translate ↗ Alt translation

Agent projects today collapse under their own prompt spaghetti and ad-hoc tool wiring. Eve's file-system-native approach makes agent behavior versionable, reviewable, and debuggable with the same workflows teams already use for web apps, lowering the barrier to production deployment.

Summary

Eve rethinks AI agent development by imposing a strict, file-system-native project structure. Each agent lives in its own directory, with an `instructions.md` file defining its behavior, a `tools/` folder of TypeScript files for capabilities, and reusable skill modules that load on demand. A built-in sandbox isolates code execution, and a scheduler turns agents into background automation systems that run on a timer.

The framework shifts prompts from ephemeral strings to engineering assets. Tool registration becomes automatic file detection, and debugging surfaces structured logs showing every tool call and state change. The result is an agent development experience that mirrors modern web application workflows—`dev` mode, visual observability, and modular composition.

Eve targets the fragmentation that plagues current agent projects: scattered logic, unobservable execution, and deployment friction. By standardizing the directory layout and execution model, it aims to make agents as maintainable and deployable as any other software system.

Takeaways

— An agent in Eve is a directory containing `instructions.md`, a `tools/` folder, and optional skill modules.

— `instructions.md` serves as the agent's behavioral specification, read at runtime as base context rather than baked into a system prompt string.

— Tools are TypeScript files dropped into `tools/`; the framework auto-detects and registers them without manual schema configuration.

— Skills are reusable, on-demand logic modules that prevent context bloat by loading only when a task requires them.

— A sandbox environment isolates all code execution and external operations from the host system.

— Scheduling turns agents into persistent background workers that can generate reports, summarize data, or trigger tools on a timer.

— Running `dev` mode surfaces structured execution traces showing tool calls, step-by-step progress, and intermediate state changes.

Conclusions

Eve's directory-as-agent model treats prompt engineering as a configuration management problem, not a model-tuning problem. The `instructions.md` file becomes a version-controlled artifact that teams can review, branch, and roll back.

Auto-registering tools from a file system removes an entire category of boilerplate that makes current agent frameworks brittle. The convention-over-configuration approach mirrors what made Rails and Next.js productive for web development.

On-demand skill loading addresses a real failure mode: monolithic system prompts that grow until they degrade model performance. Modular skills keep context lean and let agents compose behavior dynamically.

Adding a scheduler pushes agents past the chatbot boundary into cron-replacement territory. This is where agent frameworks start competing with traditional automation and ETL pipelines, not just conversational UIs.

Concepts & terms

Skills (in Eve)

Reusable, on-demand logic modules that define how an agent performs specific tasks like summarization or multi-step reasoning. They load only when needed, avoiding the context bloat of monolithic system prompts.

Sandbox (in Eve)

An isolated execution environment where an agent's code execution and external operations run, preventing unintended side effects on the host system.

instructions.md

A markdown file at the root of an Eve agent directory that defines the agent's identity, behavioral rules, and capability boundaries. It replaces ad-hoc system prompt strings with a version-controlled specification.

Source: juejin.cn ↗ Google Translate ↗ Backup ↗