Opens in a new tab
Explainer

Building an assistant that can keep its place with Eve

In brief

An engineer asks about slow checkout. The assistant investigates, then waits for approval. Eve supplies the continuing conversation and tool machinery; your team still defines the job.

8 min read

Is this the right starting point?
Before you read
Basic service, API and repository concepts; Node.js and terminal familiarity for the optional initialization.
What you will take away
Identify the runtime, authorization, retry and hosting decisions needed to operate an Eve assistant.
Sources
An open dark-green case holds brass-colored instruments, a roll of blank cream paper under a brass-colored clip, and a coral button beneath an open transparent cover.
On this page7 sections

An engineer asks in Slack why checkout has slowed down. In this hypothetical example, an assistant gathers timings, finds a recent deployment and proposes a rollback. Then the conversation waits for the person who can approve it. When that person returns, the most useful feature is not another clever answer. It is finding the investigation where everyone left it.

Eve is Vercel’s open-source TypeScript framework for the software around an AI model: instructions, tools, conversations and continuing work. Describe the assistant’s job in files, connect it to services and give it a place to receive messages. Eve runs the exchanges and tracks progress, on Vercel or infrastructure you operate. The project was in beta in the documentation reviewed for this article on October 29, 2026; interfaces and behavior are version-sensitive. [1] [2]

Installing that framework does not give the model knowledge of checkout or access to its measurements. Your team supplies those connections. Eve brings them into an assistant that can work, pause and continue without making the engineer reconstruct the conversation every time.

Open the project and read the job description

An Eve project includes agent/instructions.md, where the assistant’s job is described. Optional TypeScript files select a model and implement operations. Other directories contain procedures, channels, service connections and specialist assistants. In Eve’s vocabulary, a procedure is a skill, a callable operation is a tool, and a specialist given part of the work is a subagent. [2]

The model, instructions and tools together form an agent. The model chooses a next step; the surrounding software performs a permitted call and returns the result. In the checkout example, a deployment lookup is possible because someone supplied a tool that can actually retrieve deployments.

That arrangement gives a reviewer something concrete to inspect. The revised investigation procedure sits beside the tool that gathers its records. A change request can show when the assistant gained a new lookup. Files reveal what the team supplied; representative conversations reveal how the model uses it.

Eve includes a terminal interface, but the assistant can also meet the engineer in Slack or a web application. The project need not become a separate place people visit simply to ask about the service they were already discussing. [1] [2]

The checkout question reaches more than a model

For this hypothetical assistant, the team adds tools to read request measurements and deployment records, plus a checkout investigation skill. An engineer’s message arrives through a channel. The model reads its instructions, chooses a tool and receives its result. It might compare deployment time with the beginning of the slowdown, gather another measurement and answer in the thread.

Behind that apparently simple exchange, the pieces have distinct responsibilities:

PieceIts job in the checkout example
InstructionsDefine the assistant's scope and how it should distinguish evidence from a hypothesis.
Investigation skillExplain which checkout signals are useful and how to interpret them.
ToolsRetrieve the selected metrics and deployment records.
ConnectionAuthenticate access to an external service and expose its supported operations.
ChannelCarry the engineer's request and the assistant's response.
Durable sessionPreserve the conversation and checkpoint progress through its work.

A connection can expose operations from an MCP or OpenAPI service. MCP lets a service describe its tools and accepted inputs. OpenAPI describes HTTP operations that a connection can turn into tools. Both provide something the assistant can call; neither determines whether the returned measurements support its explanation. [6]

A deployment just before the slowdown is a lead worth following. The two timestamps do not establish cause. The assistant should explain what changed and which next observation would strengthen or weaken that connection. Instructions and tests can encourage this useful uncertainty instead of rewarding a confident answer that merely sounds complete.

Keep the investigation intact while approval is pending

Suppose the investigation supports proposing a rollback. Eve can require approval for that particular tool call, hold the work and continue after the decision. The gate must be configured in the agent-running software. Writing “ask first” in a prompt does not create the enforcement. [5]

The conversation lives in a durable session: saved messages and work that can survive an interruption. Incoming messages begin turns, and checkpoints record progress inside a turn. Eve’s Workflow SDK foundation uses those records to resume from completed steps. [4]

The illustration shows one checkout application that could use these capabilities. It is not a diagram of Eve’s internal design.

An illustrative checkout investigation reads metrics and deployments, reports insufficient evidence, or asks for human approval. Declining stops the action; approval leads to a bounded action and a service check.
One possible application workflow, not Eve’s internal architecture. Approval decides whether the proposed action runs. A separate check then asks what happened to the service.

When approval is requested, show the particular service and deployment that would change, with the basis for the proposal. “Fix checkout” leaves the approver to imagine the action. Returning a named service to a named deployment gives them a decision they can examine.

Now suppose the deployment service receives the rollback but the worker crashes before recording completion. Eve resumes the interrupted step; it does not automatically rerun a tool call when the recovered record shows the call started. Instead, it tells the model that the call may have taken effect. A later attempt by the model or integration can still deliver the request twice. The missing completion record leaves an uncertain result. [4] [5]

The integration needs a way to recognize that repeat. If the deployment service supports an idempotency key, send the same identifying key on each attempt so repeated delivery does not create another operation. Approval answers whether the change is permitted. Recognition of the repeated request answers whether it has already happened. A saved conversation does not make those two questions interchangeable. [5]

The deployment tool uses the access you gave it

Eve separates the application running the agent from an isolated work area called a sandbox. The application runs the team’s tool code, coordinates work and holds integration credentials. The sandbox provides files and processes for work such as shell commands. [4]

With a deployment tool, the consequence is direct: the tool calls the deployment service using its assigned credentials. Isolating other shell work does not narrow what those credentials permit. The tool must check the allowed service, environment and operation before making the call.

A read-only deployment lookup is a manageable first tool. Give it a service and time window and return matching records. The model gets a focused answer, while a reviewer can understand its reach without first untangling unrestricted access to an entire deployment system.

A continuing conversation needs a lasting home

Eve can run as a Node service built with Nitro. Self-hosting means supplying hosting, authentication, storage for saved work and a sandbox backend. Direct model-provider access can also be configured. Running the agent service on your machines does not, by itself, put the model there. [7]

The saved work needs storage that outlives the process. In the documented configuration reviewed here, the default local workflow store needs persistent storage and its queue delivery belongs to the process that created the work. Several copies behind a load balancer do not automatically share one queue. The documentation calls for an appropriate Workflow “world,” the backend responsible for storage and delivery, for that arrangement. [7]

Schedules introduce another multiplication risk. Each eve start process runs authored schedules unless they are disabled on additional instances. A second process intended to add capacity can therefore also create a second scheduled job. [7]

These are service-operating decisions: where work persists, who delivers it and what survives an upgrade. Eve reduces the agent coordination you must assemble yourself; availability, capacity, upgrades and ownership still need a team. The documented version limits on self-hosted session recovery matter when a conversation lasts longer than a software release. [7]

Try a question whose answer you can judge

Checkout investigation is one possible job. An assistant could also assemble an on-call handoff from approved sources, gather postmortem material or answer service questions on a web page. These are applications to build, not capabilities that acquire your organization’s information merely because Eve was installed.

Begin with a checkout conversation whose answer you can assess. Can the assistant retrieve the right records and explain what they support? Reading before granting change permission keeps the initial task specific enough to inspect.

Eve’s evaluation framework runs agent sessions and checks calls and replies. Tool stubs replace real integrations with controlled results. [8] In one case, supply a deployment before the slowdown and see whether timing is treated as a lead. In another, supply no deployment and see whether the assistant pursues another explanation rather than inventing a release.

A test that only looks for the word “deployment” would accept both a useful investigation and a very polished wrong answer. The controlled cases let you ask about the behavior the engineer actually needs.

The documented starting point requires Node.js 24 or newer, npm and a supported model credential. This command creates a project and opens its terminal interface:

npx eve@latest init checkout-assistant

Describe the job in agent/instructions.md. For later development sessions, enter the generated directory and start it with:

cd checkout-assistant
npm run dev

That creates the place to work; checkout measurements and deployment tools still need to be connected. The getting-started guide covers model connections and subsequent steps. [3]

Return to the engineer’s Slack thread. The useful promise is a continuing job with its investigation and waiting decision still attached. The team can read what the assistant was asked to do, test how it responds and operate the service around it. When the approver returns, everyone can continue from the question that was actually left open.

Sources

The capability account is scoped to documentation checked October 29, 2026. It uses illustrative application examples, not a hands-on product review; consult the documentation for the version you intend to run.

1. Eve overview.

2. Vercel Eve repository, project structure, license and beta notice.

3. Getting started.

4. Execution model and durability.

5. Tools, approval and idempotency.

6. Connections.

7. Self-hosting Eve.

8. Evaluations.

Sources & context

Sources linked in this article. Read alongside the author’s analysis; a citation does not independently verify a publisher’s claims.

Report an error or outdated detail

Keep reading

Where to go next