BlogTechnical

eve security review — defaults, approvals and the sandbox

An eve agent is a folder of files, so what it can do is readable. Its own docs say the defaults are permissive: tools run unapproved and sandbox egress is open.

Drel Research12 min read

A team has built an agent on eve and wants it approved. eve makes one part of that review unusually direct: an agent is a folder, and each tool, connection, schedule, hook and sandbox is a file in it. What the agent can do is written down where a reviewer can read it. What eve does not do is choose the safe setting for you. Its own documentation says that, unless stricter controls are configured, tools run without human approval and the sandbox's network is open.

This review is built only on eve's own documentation and source repository, as of November 2026: version 1.0.2, read at one commit on 17 November 2026, with each statement linked to the file it comes from. Drel has not tested or audited eve, and this is not a verdict on the project. Where something is not documented in the pages we read, it is listed as an evidence gap and a question.

What eve is

eve's homepage describes it as “a filesystem-first, Apache-2.0 framework for building durable backend AI agents” that runs on Vercel or on your own infrastructure. The homepage does not name a maker. The source is at github.com/vercel/eve, its NOTICE file reads “Copyright 2026 Vercel, Inc. and contributors”, and its security policy sends vulnerability reports to Vercel. The changelog dates version 1.0.2 to 17 November 2026 and 1.0.1 to the day before, so this is a very new 1.0.

The agent files reference lists what an agent/ directory may hold: agent.ts for the model and runtime settings, instructions.md for the system prompt, and one folder each for channels, connections, hooks, skills, tools, schedules, subagents, memory and the sandbox. Names come from paths: agent/tools/get_weather.ts is the tool get_weather. A repository with several agents keeps each under agents/<name>/agent/.

The security model page splits a running agent in two. The app runtime is the trusted side: tool code, model calls, connections and session state run there, with the process environment and an unrestricted network. The sandbox is the isolated side: its own /workspace filesystem, no environment variables, and a network controlled by policy. The page says only shell commands execute in the sandbox; the built-in file tools run in the app runtime and reach into it.

What happens when nothing is configured

The responsible use page is short and worth reading in full. It places the configuration of approval policies, tool restrictions, connection scopes, route and session authorization, sandbox controls and telemetry on the deployer, and then says:

Unless you configure stricter controls, eve agents may operate with permissive settings. Tools without an approval setting run without human approval, and sandbox network egress is not deny-all. Do not rely on model behavior alone to prevent sensitive or irreversible actions.

So the review starts from the defaults. The table gathers what eve's documentation says each control does when it is left alone, and the file where a team would have changed it.

When nothing is configured — per eve's documentation, November 2026

ControlIf left unsetWhere it is declared
Tool approvalA tool with no approval setting runs without a person approving it. The same holds for tools from an MCP or OpenAPI connection.The approval field of each file in agent/tools/ and agent/connections/, plus one optional agent-wide policy in agent/agent.ts.
Route authenticationProduction requests are rejected with 401 until an authenticator accepts them. Anonymous access takes an explicit none().agent/channels/eve.ts. With no file, eve applies Vercel OIDC, local development and a placeholder that refuses production traffic.
Who may use a sessionNot checked. Route authentication admits a caller to the route; eve adds no per-session access list.Application code: tools, hooks and channel handlers read the caller from ctx.session.auth.
Sandbox networkEgress is not deny-all unless a policy is set.agent/sandbox.ts or agent/sandbox/sandbox.ts, in the networkPolicy passed when the sandbox opens.
Sandbox providerVercel Sandbox on Vercel, Docker when a daemon is reachable, an in-process JavaScript shell in development only. A production build with neither fails when a session opens the sandbox.The same sandbox file. The build records the provider it chose.
Schedule identityA Markdown schedule runs as the app itself, not as a user.Each file in agent/schedules/. A handler schedule names the identity it sends with.
Run-data retentionOutside development, private and unknown-audience sessions ask for deletion when they end, if the storage backend supports it; public sessions keep the backend's default period.experimental.workflow.retention in agent/agent.ts, and the channel's audience.

Two of these fail closed and the rest fail open. Inbound routes reject what no authenticator accepts, and a production build does not fall back to the weakest sandbox. Approval, sandbox egress and access to a session are the deployer's to add.

Tools and approvals

How a tool is declared

Per the tools page, each tool is a file under agent/tools/ that exports defineTool with a description, an input schema and an execute function. Tools run in the app runtime, not in the sandbox, and can read the process environment. eve validates the model's input against the schema before execute runs, with one documented exception: for a plain JSON Schema with an unknown type name or a reference it cannot resolve, eve stops checking and execute receives the input unchecked.

Every agent also gets default tools without declaring them. The page documents bash, file read, write and edit, web_fetch, web_search and an agent tool for delegation, enabled unless defaultTools: false is set in agent.ts. It says web_fetch fetches from the app runtime and checks each destination, across up to ten redirects, for server-side request forgery. External services come in as connections: MCP servers and OpenAPI endpoints declared under agent/connections/, whose tools the model sees as <connection>__<tool>.

How a call is authorized

The human-in-the-loop page gives a tool's approval field four helpers: never(), the default when the field is omitted; always(); once(), which remembers an approval for that tool until the session ends; and auto(), which sends the tool name and input to a separate decision model and asks a person when that model answers with caution, fails or times out. A team can also write its own policy as a function of the call. One policy in agent.ts can apply to every call, including built-in tools, connection tools and local subagents; eve keeps the stricter of that policy and the tool's own, so the agent-wide policy can add a gate and never remove one.

Four details on that page matter to a reviewer:

  • A remembered once() approval “covers later calls to that tool, whatever their input.” The page adds that a remembered approval is consent, not authorization, and that the caller should be authorized on every call.
  • By default only the person whose turn requested a call can approve it. A response policy replaces that default entirely.
  • An approved call runs with the requesting user's identity, connections and credentials, never the approver's.
  • Some calls are outside the agent-wide policy: the tool-catalog search and skill tools, task controls, the built-in question, no-reply and sleep tools, connection sign-in, and tools the model provider executes itself, such as a provider's native web search.

Approval is not the same as running once. The tools page says eve never retries a tool itself, but the model can call it again, and recovery after a crash “doesn't make external effects exactly-once.” It asks for an idempotency key on charges, emails and similar effects. For the general pattern, see tool-use permission scoping and human-in-the-loop controls.

The sandbox

The sandbox page describes one sandbox per session, declared in agent/sandbox.ts or chosen by eve when the file is absent. Built-in providers do not share a sandbox across sessions. A declared subagent can opt into its parent's sandbox, in which case both work in the same files. How strong the isolation is depends on the provider:

  • Vercel Sandbox. The security model calls each one a microVM with hardware-level isolation. The Vercel provider page supports domain allow-lists and credential brokering: the sandbox's network boundary adds an authorization header for a named domain, so the secret does not enter the sandbox process.
  • Docker. Each session gets its own local container. Per the Docker page, the network policy is either allow-all or deny-all, and in eve's default image commands run as a user with passwordless sudo.
  • just-bash. A JavaScript shell with a virtual filesystem inside the app runtime process. The security model says it has a weaker boundary and no network isolation, and that custom commands registered with it run as host application code.

The default provider page says eve picks Vercel Sandbox on Vercel, Docker when a daemon is reachable, and just-bash only under eve dev or eve eval. A production build never falls back to just-bash; with no provider, the first session that opens the sandbox fails. The build records its choice, and the server uses that provider on any host.

The sandbox contains shell commands. It does not contain the agent's authored tools, hooks or connections, which run in the app runtime with the process environment by design. A review of what the model can reach therefore reads the tool files as closely as the sandbox policy. Background on the pattern: agent sandboxing and isolation.

The /eve/v1 routes

Each deployed agent serves its own HTTP API. The authentication guide lists the guarded routes: creating a session, sending to one, canceling, compacting, clearing or ending it, and reading its stream, all under /eve/v1/session. The policy lives in agent/channels/eve.ts as an ordered list of authenticators. Each one accepts, skips or rejects; if all skip, the request gets 401.

Shipped helpers cover Vercel OIDC, generic OIDC, HMAC and ECDSA JWTs, HTTP Basic, a local-development stand-in and an explicit none() for anonymous access. With no channel file, eve applies Vercel OIDC, local development and placeholderAuth(). In the source, that placeholder throws an unauthenticated error when the deployment is production and skips otherwise, which leaves the request to the same 401. The guide says the local-development helper accepts requests only on an eve dev or vercel dev server and that no request header can change this.

What the guide says is not covered:

  • Session access. “Route auth doesn't check who may use a session, and eve adds no per-session access list.” Where several users or tenants reach one route, the application implements that check.
  • The health route is public and skips authentication.
  • Vercel OIDC always accepts tokens minted for the current Vercel project, so the agent's own subagents and runtime authenticate without configuration. Other projects are admitted by an explicit subject list.
  • Forwarded identity. Another deployment can pass its end user's identity only if trustedForwarders names it. The guide warns that a predicate returning true for everyone grants that authority to every caller that passes route authentication, including preview deployments.
  • Agent info. GET /eve/v1/info returns the authored instructions and server paths, and by default serves only service and runtime principals and local development.

An agent can also be exposed as an MCP server or over A2A, each with a required auth option. The MCP channel page notes that with none() every caller is the same anonymous user, so the invocation ID “works like a password.” Platform channels such as Slack, GitHub, Telegram and Twilio verify the platform's signature over the raw body, per the security model; a custom channel has to do the same itself.

Schedules and hooks

Schedules: the agent acting with no one asking

Per the schedules page, each file under agent/schedules/ starts the agent on a cron cadence. The Markdown form is a prompt with a cron line; it runs as the app itself (authenticator app, principal eve:app, type runtime), has no channel, and discards the reply while still calling tools. A tool that needs approval fails that session instead of waiting. The handler form sends to a channel and names the identity it runs as: the app's, or a user's when the work needs that user's grants.

On Vercel, the page says each schedule invokes a private function with no public route and that failed invocations are not retried; it notes that Vercel Schedules is in beta. Self-hosted, schedules fire only inside the eve start process. The route that fires a schedule by hand needs no authentication and exists only on the development server.

The human-in-the-loop page documents a pattern for skipping approval when the caller is the app identity, so a scheduled turn can run a tool that would otherwise wait for a person. That is a reasonable design and also the first thing to look for: a tool whose policy returns not-applicable for eve:app runs unattended on every firing. An experimental API goes further and lets users and the agent create schedules while it runs; the page says eve records the creator and checks that creator's current access at each firing.

Hooks: code that runs on every event

Per the hooks guide, a file under agent/hooks/ runs after eve records an event on the session stream. Hooks run in the app runtime. They can call external services, cancel the running turn and continue a finished turn with a new message; they cannot add text to the model's context. The guide suggests them for audit logs and for copying sessions to your own database.

Three limits bear on using hooks as a control. A hook that throws fails the running turn, and eve neither retries it nor undoes what it already did. The execution model page says hooks do not run again for events written before a crash, and warns not to rely on a terminal hook for guaranteed external cleanup. And a parent's hooks do not run for a subagent's turns, so an audit hook on the root agent does not see what a subagent did unless the subagent has its own.

Secrets and durable state

Secrets

The security model keeps every secret in the app runtime's environment and none in the sandbox. Connection tokens come from a getToken() function or an interactive OAuth flow; the page says eve injects the token into each outbound request and never saves it in session state. The authentication guide adds that route-authentication secrets are never written into build output, and that user-scoped credentials are keyed by issuer and principal, so two identity providers cannot share a grant. The model sees tool definitions and results, so a secret reaches it only if a tool returns one.

What is durable, and where

eve runs each session as a workflow. The workflow worlds page says the storage backend holds each run's event log, step results, pending input and streams: managed by Vercel on Vercel, files under .eve/.workflow-data for a single self-hosted process, or a PostgreSQL database for several replicas. Conversation content and tool results therefore sit in that backend. Per-session values an agent declares with defineState survive crashes and redeploys, and a session's sandbox files persist across turns while the provider still has them.

Lifetimes, as documented: a session completes after 30 idle days by default (sessions page). The agent configuration page says that, outside development, private and unknown-audience sessions request deletion of run data when they end, where the backend supports deletion, and public sessions keep the backend's default period. An approval or a sign-in can hold a turn open “seconds or days”, with the pending call stored meanwhile. The security model also says eve records local traces in development and exports to Vercel Agent Runs in preview and production by default.

For recovery, the execution model page is explicit: completed steps replay their saved result, an interrupted step runs again, and a call reported as interrupted “may have taken effect.”

Published vulnerabilities

On 17 November 2026 the repository's security advisories page listed no published advisory, and a web search for a CVE or advisory naming eve returned none. That describes the public record on that date and nothing more. The 1.0 line is days old, so there has been little time for outside research to be done or published, and an empty list is not evidence of an audit. Check the advisories page again on the day of the decision, and pin the version the agent ships with.

Advisories against what an eve agent is built on are a separate question: the model SDK it uses, each MCP server it connects to and the sandbox image. Those have their own records; see known vulnerabilities in the AI agent stack.

Evidence gaps

These were not documented in the pages and files we read. Each is a question for the team that built the agent or for eve's maintainers:

  • An independent security assessment. We searched the repository's docs folder, README and SECURITY.md for a penetration test, a third-party audit, a bug bounty and SOC 2, and found no mention of any. Ask whether one exists and for whom it is available.
  • Guidance on prompt injection. The same search found no page that uses the term. The security model describes where secrets live and what the sandbox can reach, not how the agent should treat instructions inside content it reads.
  • Encryption of stored session data on a self-hosted deployment. The pages we read say the local backend writes files under .eve/.workflow-data and the Postgres backend writes to a database; they do not describe encryption of either. One page mentions an encryption key that belongs to a Vercel deployment, without describing the scheme.
  • How long each storage backend keeps run data by default. The documentation says some sessions keep "the World's default retention period" and does not state the period in the pages we read.
  • What the default trace export contains. The security model says eve exports to Vercel Agent Runs in preview and production by default, and that product is described as beta. Which fields of prompts, tool inputs and tool results are exported, and how to turn the export off, should be confirmed for the deployment under review.
  • A support and patch policy for the 1.x line: how long a release receives security fixes, and how a fix is announced. SECURITY.md gives a reporting address and nothing more.
  • How the default container image is built and verified. The Docker page names the image registry and says commands run as a user with passwordless sudo inside the container; we did not find a statement on image signing or provenance.

Review checklist

For an agent built on eve, the review should be able to answer each of these from the repository and the deployment settings:

  • List every file under agent/tools/ and agent/connections/. For each one that writes, sends, pays or deletes, is approval set, and to what? An absent field means the call runs unreviewed.
  • Is there an agent-wide approval policy in agent/agent.ts, and does it catch connection tools and destructive calls the individual files miss?
  • Where once() is used, does one approval cover inputs that should be approved separately, such as another tenant or a larger amount?
  • What does agent/channels/eve.ts contain? Is placeholderAuth() gone, is none() absent, and does an unauthenticated production request return 401?
  • If more than one user or tenant reaches the same route, where does the application check that the caller may use this session? eve does not.
  • Is trustedForwarders set, and is it narrower than "any caller that passes route authentication"?
  • Which sandbox provider did the production build record, and what network policy opens with it? If the answer is allow-all, what can a command inside it reach?
  • Which default tools are enabled? bash, the file tools, web_fetch and web_search are on unless defaultTools is false. web_fetch runs from the app runtime, not from the sandbox.
  • For each schedule: which identity does it run as, which tools can that turn call, and does any tool skip approval for the app identity?
  • Are dynamic schedules mounted? If so, who can create one, and what is the widest action a scheduled occurrence can take?
  • Does every tool with an irreversible effect carry an idempotency key or its own check? Recovery after a crash can run a call again.
  • Which storage backend holds sessions, who can read it, what retention is requested, and where do traces go?
  • If an audit trail is built on hooks, does it cover subagent turns? A parent's hooks do not run for them.

The framework-agnostic version of this list is in the AI security review checklist. For another framework read the same way, see LangChain and LangGraph.

Framing the decision

The decision is about the agent, not about eve. The same framework yields a read-only assistant behind single sign-on and an unattended agent that can issue refunds; what separates them is in the files above. Written with its conditions, each outcome looks like this:

  • Approve where routes sit behind a real authenticator, every tool with an outside effect has an approval policy or is read-only, the production sandbox is a microVM or container with a network policy narrower than allow-all, schedules run only read or idempotent work, and the storage backend and trace export are known and accepted.
  • Conditional approval where the design is sound and specific items are open: an agent-wide approval policy to add, session-level authorization to implement for a multi-tenant route, idempotency keys on named tools, a retention setting, an answer on trace content. Each condition names an owner and a date.
  • Restricted pilot where the team is still learning what the agent does: a named group of users, non-production data and credentials, default tools turned off except those needed, deny-all sandbox egress with listed exceptions, no dynamic schedules, and a fixed end date. See the restricted pilot pattern.
  • Reject, for now, where anonymous access is enabled on an agent that holds credentials, where irreversible tools run with no approval and no idempotency, where a scheduled turn skips approval for a tool that moves money or deletes data, or where production relies on the in-process shell.

Record what the decision rested on: the eve version, the commit of the agent's repository, the files read, the open questions and who signed. A framework at 1.0.2 will change, and the sign-off should say which version it covered.

Sources

Blog

Get new posts in your inbox

AI security review, OWASP Agentic Top 10, ISO 42001 evidence, and what AI Committees actually need. No cadence promises — we publish when there's something worth reading.

Review an eve agent before it runs unattended

Tools, approvals, sandbox egress and schedules, mapped to an approval decision your AI Committee can sign.

A note on scope: Drel reviews assessed systems against documented architecture, configuration and intent. It does not ingest live telemetry from production environments. Dispositions reflect the assessed system at the time of review and the re-assessment triggers that govern when the disposition must be revisited.