Eve lets efficient agent creation with Markdown and TypeScript tools

Eve is Vercel’s take on what a real agent can be: self-contained, Markdown-defined, and developer-extensible by convention, not complexity. You can run a full-featured Eve agent just by dropping an instructions.md file into your repo—no special prompt hacking or orchestration code. From there, skills, tools, connections, subagents, and scheduling add up to a platform for shipping agents that don’t just answer, but act. Here’s how Eve on Vercel changes the game for shipping AI logic, not just AI wrappers, and how you can use it now.

What is the Eve agent on Vercel and how does instructions.md define it?

The core innovation: on Vercel, an Eve agent is born the moment you add an instructions.md file. This single Markdown file is the canonical contract for your agent’s behavior. It describes intent, workflow, and instructions directly in Markdown—no wrapper code or prompt chains needed.

How does it work?

• Place an instructions.md at the root of your agent repo.
• The file is loaded by Eve and becomes the agent’s full behavioral definition.
• Eve uses this as the operational baseline: the agent needs no further prompt guidance unless you extend it.

Why is this different? Most systems blur the line between “agent instructions” and backend wiring: prompts sprawl across code, YAML, and secret configs. Here, instructions.md is the contract. The agent’s brain is Markdown, which ships and versions cleanly.

If you want more—specific model selection, runtime tweaks—add an agent.ts file to override the default settings. This separation keeps the default path frictionless but fully open for escape hatches.

Takeaway: Eve treats Markdown as the logic layer. Write your agent as a document, not a codebase.

How to run Eve agent with default settings

You can launch an Eve agent on Vercel with just two ingredients: the Eve runtime (powered by Vercel infra) and your instructions.md. No heavy scaffolding or config bloat.

Minimal steps:

// At your project root, add instructions.md
# Order Tracker Agent

You are an AI assistant for tracking and updating customer orders...

Then run Eve—the runtime auto-detects your instructions.md and provisions the agent.

• Without an agent.ts, Eve picks a default model for you.
• You get a fully isolated sandbox and built-in file tools by default.
• The process is zero-boilerplate: no registration or CLI wizard; Markdown is the API.

Behind the scenes: Eve's default setup spins up an isolated execution environment (sandbox). This means file access and code execution are scoped and safe, ideal for running autonomous agent logic.

The critical insight: The default Eve path is “just ship the behavior as Markdown and go live.”

How to customize Eve agent with agent.ts and sandbox

Defaults work, but agents are rarely one-size-fits-all. To tune your agent, Eve supports two key extensibility points: agent.ts and sandbox/sandbox.ts.

When to add an agent.ts file:

• You want to pick a custom model (e.g., move from a default to a specialized LLM).
• You need to set runtime options Eve doesn’t cover out of the box.

Sample agent.ts override:

// agent.ts
export const model = "gpt-4-o";      // Pin to OpenAI GPT-4o
export const maxTokens = 4096;       // Limit token count for tighter outputs

Customizing the sandbox: By default, each agent runs in its own isolated environment (sandbox), but you can further tailor this by dropping a sandbox/sandbox.ts file into your repo.

What can you do here?

• Choose a different backend for code evaluation or file system access.
• Add setup options specific to your workload.

Example sandbox config:

// sandbox/sandbox.ts
export const backend = "d1";         // Switch to an alternate backend
export const timeout = 90;           // Extend execution timeout

The setup is discoverable and convention-first—drop in files, adjust a few exports, and Eve takes care of wiring them up. No arcane build steps.

Takeaway: With Eve, model selection and runtime tuning are composable via a single code file.

What are Eve skills and how to use Markdown playbooks?

Eve agents scale up without turning into spaghetti prompt chains. Enter skills: Markdown playbooks loaded contextually when the agent needs them.

Skills = Focused, modular guidance.

• Add a skill as a Markdown file in your skills folder (e.g., skills/order-lookup.md).
• Eve loads the skill only when context signals it’s needed—no need to inject everything into the initial prompt.
• Skills are self-contained: each Markdown playbook is an atomic piece of procedural or domain knowledge.

How does this help?

• Agents get sharper, more relevant instructions at runtime.
• You avoid the "giant prompt" anti-pattern that clutters model input.

Example skill (skills/order-lookup.md):

# Order Lookup

When the user provides an order ID, query the orders database and return the results in JSON.

Adding a new skill: Just drop an appropriately described Markdown file into the skills directory; Eve handles loading and context routing.

Takeaway: Skills let you scale agent capabilities without inflating the core agent prompt.

How to use Eve’s tools, connections, and subagents for complex workflows

The real power of Eve shows up when orchestration, integration, and automation enter the picture.

Tools:
Add a TypeScript file to the tools/ directory, and it becomes callable by Eve—no explicit registration. The filename is the tool name.

Example (tools/fetchOrders.ts):

export default async function fetchOrders(orderId: string) {
  // Custom business logic
  return await fetchFromDB(orderId);
}

How it works:

• Tools appear as functions Eve can invoke at runtime.
• Any special logic, fetch, or calculation can become a tool. No boilerplate.

Connections:

• Managed in the background, connections handle authentication for services like GitHub, Stripe, and Linear.
• Tools can use these connections without handling OAuth flows or token logistics directly.

For example:
A tool that posts an update to a Stripe account can authenticate via connection—not by embedding API keys in code.

Subagents:

• When you add subagents, the main Eve agent can delegate tasks and merge responses.
• Example: one subagent monitors Slack, another processes GitHub PRs. The primary agent synthesizes their outputs.

Multi-channel & Scheduling:

• Drop a file in the channel folder to surface the same agent logic in Slack, Discord, Microsoft Teams, or web UIs.
• Use the scheduling feature to run agents on cron for daily reports, weekly digests, or background jobs—no user session required.

Sample use cases worth the effort:

• An Eve agent that collates bug tickets daily across Linear and GitHub, emails a summary, and posts to Slack—the tools, connections, and scheduling all work in orchestrated harmony.
• Triggering an agent automatically each morning to post a project status digest in a Discord channel.

Takeaway: Eve agents aren’t just reactive—they automate, integrate, and operate as distributed orchestrators, not just chatbots.

What this enables: a one-file agent with enterprise extensibility

With Eve, shipping an agent is as simple as writing a document—but growing it into a workflow engine isn’t a refactor.

• You start with a single Markdown file—your product support agent is live in minutes.
• Adding skills: drop-in Markdown for each new department or workflow, loaded only when necessary.
• Need API calls or business logic? Write a short tool as a TypeScript function, no glue code.
• Want to automate: schedule your agent to report daily, summarize weekly, or escalate in real time.

In every case, the extension is composable: you add small files, not frameworks or giant manifests. Developers building modern SaaS, ops, or support agents are no longer bottlenecked by agent plumbing or config.

Eve on Vercel: the agent layer you control

Eve on Vercel makes AI agent logic as transparent and fluid as the rest of your stack: Markdown for intent, TypeScript for logic, one-agent-per-folder for scale. Every customization—model, runtime, tool, channel, subagent—is a drop-in, not a rebuild.

For any developer shipping autonomous, integrated workflows, the Eve agent on Vercel is the shortest path from Markdown to production agent. One clean file, ready to serve, and a path to real extensibility—at a fraction of the usual agent-wrangling effort.

If you’re building on Vercel and want more than a chat wrapper, start with instructions.md. Everything else is a file away.