跪拜 Guibai
← Back to the summary

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

Vercel Launches Agent Framework Eve: Making AI Agents as Simple as Building Web Applications

Eve is a development framework designed around the "engineering of AI Agents." Its goal is clear: to transform building intelligent agents from a patchwork of prompts into structured, maintainable software engineering.

Judging from Eve's official introduction, it is not about "reinventing model capabilities" but about redefining the organizational structure of Agents. If we were to summarize its approach in one sentence, it would be: Eve attempts to turn AI Agents into a standard software project structure.

In traditional development, we are accustomed to organizing systems with code, modules, and configurations. In many Agent frameworks, the problem lies precisely in the "lack of structure"—logic is scattered among prompts, tool calls, and external services, making it difficult to maintain. The path Eve chooses is the opposite: define the structure first, then carry the capabilities.

image.png

1. A Directory-Centric Agent Model

Eve's core design philosophy is that "an Agent is a directory."

Within this directory, the most basic component is instructions.md. Its role is similar to core configuration or behavioral specifications in traditional software, but closer to a "system manual." Developers define the Agent's identity, capability boundaries, and behavioral patterns here.

For example, a simple Agent might only need one sentence:

You are an assistant that can query the weather, responsible for providing weather information for cities worldwide.

Eve reads this file at runtime and uses it as the Agent's base context. In other words, the Agent's "personality" and "behavioral rules" are no longer implicitly existing within a prompt but explicitly become part of the project.

The biggest change brought by this design is: Prompts are no longer temporarily concatenated strings, but engineering assets.

2. Tool System: From "Calling APIs" to "Files as Capabilities"

In Eve, the design of tools is very direct: a tool is a TypeScript file.

Developers only need to create corresponding files in the tools/ directory, such as get_weather.ts or search.ts, and the system will automatically recognize and register them as callable capabilities for the Agent.

This approach has two distinct characteristics:

First, it reduces cognitive load. You no longer need to register tools, configure schemas, or maintain complex call chains.

Second, it reinforces engineering consistency. Tools and code naturally exist within the same system, no longer acting as "external APIs."

From an architectural perspective, this design makes extending an Agent's capabilities as natural as "adding a module."

3. Skills: A Reusable Behavioral Experience Layer

Beyond tools, Eve introduces a concept called Skills, which can be understood as "behavioral capability packages."

Skills are not fixed loaded prompts but logic modules injected on demand. For example:

The key points here are "reusability" and "on-demand loading." In traditional prompt engineering, we often pile all rules into the system prompt, leading to bloated context. Eve's approach is to split these capabilities into independent modules and combine them when needed.

This design is closer to the "plugin mechanism" in modern software.

4. Sandbox: A Secure Execution Environment

Once an Agent possesses execution capabilities, an unavoidable issue is security. Eve's solution is to introduce a sandbox environment.

All tasks that may involve code execution or external operations run in an isolated environment. This means the Agent can have strong automation capabilities, such as data processing or script running, without directly affecting the main system environment.

From an engineering perspective, this adds a "security boundary" to the Agent.

5. Scheduling and Automation Capabilities

Eve also provides scheduling capabilities, allowing Agents to execute tasks on a timer.

For example:

This transforms the Agent from a mere "conversational tool" into a "background-running automation system."

From a product form factor perspective, this step is crucial; it extends the Agent from "interactive" to "continuously running."

6. Developer Experience: From Command Startup to Visual Debugging

In terms of developer experience, Eve provides a relatively direct approach:

Developers can quickly create a project via an initialization command, then run the Agent in dev mode. During this process, they can observe in real-time:

This observability is very important because it solves a long-standing problem: the inexplicability of AI Agent behavior.

Through structured logs and execution flow displays, Eve makes the entire system closer to the traditional software debugging experience.

7. Overall Positioning: An Engineering Framework for AI Agents

Overall, Eve is not about enhancing model capabilities but about enhancing the "development approach."

The core problems it attempts to solve include:

Eve's answer is: reorganize Agents using software engineering methods.

Conclusion

From Eve's design philosophy, a trend is visible: AI Agents are moving from "experimental play" to "engineered systems."

If early Agents were like "building with Lego," what Eve aims to do is turn those Legos into a set of standardized architectural blueprints.

It doesn't make Agents more mysterious; rather, it makes them more like a part of software engineering—clearly structured, with defined responsibilities, scalable, and deployable.

This is also Eve's most fundamental value: not making Agents smarter, but making Agents more like a real software system.