eve — A Framework for Building Durable Agents
The open framework for building agents with a filesystem-first approach for durability and observability.
Evidence shows a filesystem-first design with tools and skills in defined locations, but no explicit permission model or least-privilege principle. User confirmation exists (e.g., human-in-the-loop prompts) but not detailed. Data flow transparency is limited; no clear explanation of data flow or storage. Sensitive data handling not mentioned. Dependency security has syncpack checks but no vulnerability scanning evidence. External effects (e.g., network calls) not explicitly restricted. Rollback mechanism not mentioned. Source attribution has Vercel branding and license, but publisher unverified. Deductions: lack of permission model, data flow transparency, and sensitive data handling specifics.
Self-consistency is good; README and code structure align, but no runtime behavior verification. Dependency availability has pnpm-lock and workspaces, but not verified. Failure messages have test code but no user-facing error handling documentation. Deductions: no runtime verification and detailed failure handling docs.
Target audience clear (developers), scenarios include quick start and existing project integration. Capability boundaries defined via filesystem structure but not explicit limits. Trigger precision (e.g., cron schedules) has examples but not detailed. Environment fit has Node>=24 and cross-platform tests but no detailed configuration. Deductions: trigger precision and boundary definitions not detailed enough.
Information architecture clear with README and docs links. Install notes have npx eve init. Naming stability not explicit but version control exists. Examples and FAQ have quick start and community links. Known limitations mention beta terms. License is Apache-2.0. Versioning changelog not provided. Maintenance responsibility has contributing guide and security policy. Deductions: missing versioning changelog and detailed known limitations.
Output usability has examples and docs but no actual output verification. Marginal value high with filesystem-first framework. Cost-benefit not assessed but open-source free. Deductions: no actual run verification and cost analysis.
Claim traceability limited; README claims features but no test evidence. Cross-source corroboration has CI config and test scripts but not independently verified. Fact-inference separation unclear. Deductions: lack of test results and independent verification.
- Publisher identity unverified; treat source with caution.
- Framework in beta; APIs and behavior may change.
- No permission model or sensitive data handling details; assess before deployment.
- Dependency security relies on syncpack only; no vulnerability scanning evidence.
What does this agent do, and when should you use it?
eve is an Apache-2.0 licensed framework from Vercel for building durable, filesystem-first AI agents. Its core idea is that the filesystem is the authoring interface: agent capabilities like instructions, tools, skills, channels, and schedules live in conventional file locations, making projects easier to inspect, extend, and operate. Written in TypeScript, it provides APIs such as defineTool and defineAgent, and supports model configuration, tool calls, message channels (HTTP, Slack, Discord), and cron schedules. Installation and initialization are done via npx eve@latest init, and the generated project includes full documentation locally. The framework is currently in beta, so its APIs may change. Overall, eve offers a standardized development paradigm for agents that need persistence, deployment, and observability.
eve provides a scaffolding CLI (npx eve@latest init) to create a new agent project or add to an existing project (npx eve@latest init .). It generates a project structure with an agent/ directory where instructions.md holds the system prompt, tools/ directory uses defineTool to define typed functions the model can call, skills/ contains procedural documents loaded on demand, channels/ defines message channels (HTTP, Slack, Discord), and schedules/ defines recurring cron jobs. Agent model and runtime config are set via defineAgent in agent.ts. Running npm run dev launches the interactive terminal UI and starts the agent. The framework uses the filesystem as the persistence layer, making state and configuration inspectable and versionable.
- Developers wanting to quickly build self-hosted agents can use the scaffold to initialize a project and customize behavior by editing instructions.md and adding tools.
- Teams needing to serve agents across multiple channels (e.g., Slack, Discord) can configure message channels via the channels/ directory.
- Operations engineers requiring recurring tasks (e.g., weekly reports) can use cron definitions in the schedules/ directory.
- Developers wanting to integrate an agent into an existing Node.js project can run npx eve@latest init . in the project directory.
- Teams needing durable agent state that is easy to audit and extend can benefit from the filesystem-first design.
- Developers exploring agent framework best practices or learning to build agents can refer to the built-in documentation in node_modules/eve/docs.
What are this agent's strengths and limitations?
- Filesystem-first design makes agent configuration and logic easy to review, version-control, and extend.
- Supports multiple message channels (HTTP, Slack, Discord) and scheduled jobs, enabling integration into workflows.
- Provides a scaffolding CLI to quickly initialize new projects or add to existing ones.
- Backed by Vercel and has an active community on GitHub Discussions.
- Currently in beta; APIs and functionality may change before general availability, not suitable for production yet.
- Requires Node.js and npm, limiting to environments with Node.js support.
- Model compatibility is not explicitly documented; may be tied to specific providers like Anthropic.
- Requires learning the framework's directory structure and APIs, with a learning curve.
How do you install or deploy this agent?
Prerequisites: Node.js and npm. The eve CLI is not installed globally in the source; it is invoked via npx. To create a new project: run npx eve@latest init my-agent, then cd my-agent and run npm run dev to start.
How do you use this agent?
1) Initialize a project: npx eve@latest init my-agent. 2) Enter the directory: cd my-agent. 3) Edit agent/instructions.md to set the system prompt, e.g., 'You are a concise weather demo assistant. Tell users that the weather data is mocked.' 4) Add a tool at agent/tools/get_weather.ts using defineTool. 5) Choose a model in agent/agent.ts using defineAgent, e.g., model: 'anthropic/claude-sonnet-5'. 6) Run npm run dev to start the agent. 7) Add human-in-the-loop prompts, subagents, and schedules as needed.
How does this agent compare with similar options?
eve falls into the agent framework category alongside tools like LangChain or Autogen, but its filesystem-first approach sets it apart. However, the source does not mention specific competitors, so no direct comparison is provided.