evelab is the open source visual IDE for AI agents built on Eve. Design your agent on a canvas, plug in tools, skills, MCP servers and chat channels, and ship production-ready TypeScript that you fully own.
Website · Templates · Eve docs · Report a bug
Eve is a framework for building durable AI agents in TypeScript. An Eve agent is a folder of plain files, and you run it with the eve command.
evelab is the visual layer on top. It lets you see and build that folder as a diagram. You design the agent in evelab, the files it writes are a normal Eve project, and Eve runs it.
| Eve (eve.dev) | evelab | |
|---|---|---|
| What it is | The framework and CLI that runs AI agents | A visual IDE for designing and editing Eve agents |
| How you build | Write each file by hand in your editor | Drag pieces onto a canvas, or edit the code. Both stay in sync |
| Seeing the big picture | Read through the folder | Every agent, tool, skill and channel in one live diagram |
| Connecting services | Write the connection and channel files | Pick Slack, Linear, an MCP server and more from a catalog |
| What you end up with | An Eve project | The exact same Eve project, with nothing extra added |
| Running the agent | eve dev and eve deploy |
Your agent always runs on Eve |
evelab does not replace Eve. It makes Eve faster to learn, easier to see and quicker to build with.
Building an AI agent usually means juggling a pile of files: instructions, tools, skills, sub-agents, connections to other services and the chat apps it lives in. It is hard to see how it all fits together.
evelab turns that pile into a picture.
- See your whole agent at once. Every piece is a card on a canvas, wired to the agent that uses it.
- Build by dragging. Drop a tool, skill, channel or MCP server onto an agent and evelab writes the file for you.
- Keep real code. Everything is a normal Eve project. Open it in any editor, commit it, run it with
eve dev. No lock-in, no hidden format. - Change either side. Edit the canvas and the code updates. Edit the code and the canvas redraws.
| Visual canvas | Agents, sub-agents, tools, skills, connections and channels drawn as one architecture. Tree, row or freeform layouts, notes and sections, undo and redo, minimap and keyboard shortcuts. |
| Drag and drop building | Drag a piece onto an agent to attach it. Share one tool or skill across many agents. Detach a wire to remove it. |
| MCP and OpenAPI | Paste an MCP server URL, see its tools and choose which ones your agent may call. Connect OpenAPI services too. |
| Channels | Put your agent in Slack, Discord, Microsoft Teams, Telegram, Twilio, GitHub, Linear and more. |
| Skill import | Bring in skills from GitHub or skills.sh. evelab shows every file and flags anything that can run code before it installs. |
| Code editor | Monaco for every file, a Zed style file explorer, autosave, quick open and a command palette. |
| Built-in assistant | An AI assistant (Ctrl+I) that reads your project and builds pieces through the same operations as the UI. |
| GitHub, both ways | Import any Eve repo, review changes side by side, commit, push and pull. |
| Export anywhere | Download a zip that runs with npm install and eve dev, or push it straight to GitHub. |
| Teams ready | Optional GitHub sign-in with private, per-account projects. |
| Polished everywhere | Light and dark themes, responsive from phone to wide screen, skeleton loading states and accessible controls. |
The idea behind evelab is simple: the files are the source of truth, and the canvas is a live view of them.
- Read. evelab parses the project into a typed model and turns it into a graph.
- Draw. The canvas shows that graph: who owns what, who shares what and how messages reach the agent.
- Change. When you drag a piece, rename something or edit code, evelab updates the exact file involved and leaves the rest of your code untouched.
- Save and redraw. The project is read again, so the canvas always matches what is on disk.
evelab is a Next.js app on top of a small set of focused packages. Every service beyond the core is optional: with nothing configured it runs as a local, single-user tool on your filesystem.
| Piece | What it does |
|---|---|
Web app (apps/web) |
The whole product: landing page, projects, canvas, agent editor, resource pages, file explorer, source control and the assistant. |
Project engine (packages/eve-project) |
Reads an Eve project into a typed model, validates it, turns it into a graph and writes code back. Its round trip is covered by tests so your files never lose anything. |
GitHub client (packages/github) |
Reads repository trees, works out what changed, plans safe pulls that never overwrite your edits, and makes commits. |
Auth (packages/auth) |
Optional GitHub sign-in through Better Auth, so each person only sees their own projects. |
Database (packages/db) |
Drizzle schema for users, sessions, project membership, repository links, and project files when running on Vercel. |
evelab picks the right place automatically:
Your project files are never mixed with evelab's own state. Canvas positions, repository links and history are kept separately, so a project folder is always a clean Eve project.
| Area | Tools |
|---|---|
| Framework | Next.js 15 (App Router, Server Actions), React 19, TypeScript |
| Canvas | React Flow, Dagre for automatic layout |
| Editor | Monaco |
| UI | Tailwind CSS 4, Radix UI, shadcn/ui, Motion, Geist |
| AI | Vercel AI SDK, Vercel AI Gateway, Model Context Protocol SDK |
| Data | Postgres with Drizzle ORM, Vercel Blob |
| Auth | Better Auth with GitHub |
| Platform | Vercel, Vercel Sandbox, Vercel Workflow |
| Tooling | pnpm workspaces, Turborepo, Vitest, Playwright |
You need Node.js 22.13+ and pnpm.
git clone https://github.com/anishfn/evelab.git
cd evelab
pnpm install
pnpm startOpen http://localhost:3000 and create your first agent. That is it: no accounts, keys or database needed to get going.
For development with hot reload:
pnpm --filter @evelab/web devYour projects are saved in .evelab/workspace/. Each one is a normal Eve project, so you can cd into it and run eve dev at any time.
Everything below is optional. Copy .env.example to .env and turn on only what you need.
| Variable | Turns on |
|---|---|
EVELAB_WORKSPACE |
A different folder for your projects |
AI_GATEWAY_API_KEY |
The live model list and the assistant |
EVELAB_ASSISTANT_MODEL |
A different assistant model (default anthropic/claude-sonnet-5) |
GITHUB_TOKEN |
Import, commit, push and pull with a personal access token |
GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY, GITHUB_APP_INSTALLATION_ID |
Source control through a GitHub App instead of a token |
DATABASE_URL, GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, BETTER_AUTH_SECRET, BETTER_AUTH_URL |
GitHub sign-in with private projects (set all of them, then run pnpm --filter @evelab/db db:migrate) |
BLOB_READ_WRITE_TOKEN |
Store layouts and app state in Vercel Blob |
EVELAB_STORAGE |
Force fs or database storage for projects |
NEXT_PUBLIC_SITE_URL |
The public address used for links and share images |
- Import this repository into Vercel and set the root directory to
apps/web. - Add a Postgres database (for example Neon from the Vercel Marketplace) and set
DATABASE_URL. - Create a GitHub OAuth app with the callback
https://<your-domain>/api/auth/callback/github, then setGITHUB_CLIENT_ID,GITHUB_CLIENT_SECRET,BETTER_AUTH_SECRETandBETTER_AUTH_URL. - Run
pnpm --filter @evelab/db db:migrateagainst the database. - Optionally add
AI_GATEWAY_API_KEY,BLOB_READ_WRITE_TOKENandNEXT_PUBLIC_SITE_URL.
On Vercel, evelab stores project files in Postgres automatically, because a serverless disk does not keep files between requests.
apps/web The evelab web app
packages/eve-project Project engine: parse, generate, validate, graph
packages/github GitHub client: trees, status, safe pulls, commits
packages/auth GitHub sign-in with Better Auth
packages/db Drizzle schema and migrations
pnpm test # unit tests across the workspace
pnpm typecheck # TypeScript across the workspace
pnpm build # production build
cd apps/web
CHROMIUM_PATH=/usr/bin/chromium pnpm e2e # browser testsStop any running dev server before pnpm build, since both use the .next folder.
- Visual canvas with drag and drop building
- Tools, skills, sub-agents, connections, channels and schedules
- MCP and OpenAPI connections
- GitHub import, commit, push and pull
- Built-in assistant
- Private projects with GitHub sign-in
- Runs: chat with your agent and watch every tool call live, in Vercel Sandbox
- Observability: usage, cost, latency and errors for every run
- One click deploys to Vercel with
eve deploy
Ideas, bug reports and pull requests are all welcome. Open an issue to talk about a change, or send a pull request with a short description of what it does.
If evelab helps you build agents, give it a star so more people can find it.