EveStudioDocs

Connections & channels

Two sides of the same coin:

  • Connections: how your agent reaches out to other services (their tools become the agent's tools).
  • Channels: how people reach your agent (Slack, web, GitHub, …).

Both live in the Integrations tab in Eve Studio, with a sub-tab for each, plus an Add from registry gallery that installs anything in the official eve catalog.

Add from registry

Eve distributes channels, connections, extensions, memory providers, and instrumentation through a registry, installed with one command:

eve add <item>            # e.g. eve add channel/discord, eve add extension/arcana
eve registry list         # everything in the official catalog
eve registry search <q>   # find an item
eve registry view <item>  # inspect before installing

Studio's Add from registry · eve add gallery wraps that. It lists the official catalog (fetched with eve registry list --json and cached per agent for ten minutes; a refresh icon forces a re-read), lets you filter with chips (All, Channels, Connections, Extensions, Memory, Instrumentation, Other) and search by name, address, or description, and shows each item's description and a docs link to its page on eve.dev/integrations. Channels with a guided wizard are marked guided setup · Channels instead of an Install button. Install runs:

eve add <item> --non-interactive --yes

Progress streams into the in-app console. --yes accepts an item's recommended setup answers. When it finishes, the panel lists the files written, the environment variables added to .env.local for you to fill in, whether a deploy is needed, and a Restart button for the dev server. Some items need an answer Studio can't guess (a connector to pick, a project to link); in that case eve add exits with code 2, and the panel reads Setup needs an answer Studio can't guess, names any prerequisite (usually eve link), and prints the continuation command to finish in a terminal from the agent folder.

Review what an install added before you run the agent. Registry items are project files and dependencies, the same as code you'd write.

Connections

A connection points your agent at an external service and exposes its tools to the model. Files live in agent/connections/; the filename is the connection name, and discovered tools are called as <name>__<tool> (e.g. linear__create_issue). The model finds them through connection_search, so the description you write matters: it's the routing signal.

MCP connections

Use MCP when the service already runs an MCP server that publishes its own tools.

import { connect } from "@vercel/connect/eve";
import { defineMcpClientConnection } from "eve/connections";

export default defineMcpClientConnection({
  url: "https://mcp.linear.app/mcp",
  description: "Linear workspace: issues, projects, cycles, and comments.",
  auth: connect("mcp.linear.app/linear"),
});

OpenAPI connections

Use OpenAPI when the service publishes an HTTP API contract. Eve generates one tool per operation with defineOpenAPIConnection.

Authorizing with Vercel Connect

For OAuth-backed services, prefer Vercel Connect: it owns the browser consent flow, encrypted token storage, refresh, and project access, so credentials never touch model context. The connect() helper wires that lifecycle into the connection's auth.

  • User-scoped (default): connect("<connector-uid>"). The first call for a new user parks the turn on an authorization.required event with a sign-in URL, then resumes.
  • App-scoped: connect({ connector: "<uid>", principalType: "app" }). The connection acts as the agent itself, non-interactively.

Static credentials

Not everything needs OAuth. A connection can also authenticate with a static bearer token from an environment variable (auth: { getToken }), or a custom header. Set those in the Deploy → Environment panel.

Managing connections in Studio

Integrations → Connections is laid out top to bottom:

  • This agent's connections: every connection Eve discovered, meaning the files in agent/connections/ (authored by you, by a guided wizard, or by eve add connection/<name>) and connections contributed by a mounted extension. Each row shows its protocol badge (mcp or openapi) and URL. Authored rows Open the file in the editor and have a Delete icon. Extension rows are badged via extension <ns> (for example Arcana's arcana__memory), have no delete, and Open edits the mount file under agent/extensions/ instead. Add opens a form: a name, MCP server or OpenAPI / REST, the URL, a description, and an auth mode (static bearer token from an env var, a custom header, Vercel Connect user or app OAuth, or none); Studio writes connections/<name>.ts.
  • Vercel Connect: the connectors on your Vercel team, split into Attached to this agent (referenced by the agent's files or attached to its project) and a collapsed Other connectors on your team. Add connector opens Vercel Connect to create one; Use in agent writes the connection (or, for Slack, GitHub, and Linear, the channel) code wired to that connector's UID, then offers Attach for triggers.
  • Add from registry · eve add: the registry gallery filtered to connections, extensions, memory providers, and instrumentation (channels live in the Channels sub-tab).

Channels

A channel is the edge adapter between a platform and your agent. It normalizes platform input into a message, owns the conversation's address, and decides how a reply is delivered. Channel files live in agent/channels/; the file stem is the channel id. Local subagents don't declare channels.

The default HTTP channel

Eve's HTTP channel is always on. It's the session API that Studio chat, the terminal UI, and curl all talk to (POST /eve/v1/session, GET …/stream, and the cancel/compact/clear/reset routes). eve init writes agent/channels/eve.ts with the default auth stack; edit it to change route auth.

Platform channels

| Channel | Auth | Install | | --- | --- | --- | | Slack: @mentions, DMs, threads, HITL buttons | Vercel Connect | guided wizard · eve add channel/slack | | GitHub: @mentions, PR review | Vercel Connect | guided wizard | | Linear: issue delegation, agent sessions | Vercel Connect | guided wizard · eve add linear | | Discord: slash commands, components | Env vars | guided wizard · eve add channel/discord | | Microsoft Teams: messages + Adaptive Cards | Env vars | guided wizard · eve add channel/teams | | Telegram: bot messages | Env vars | guided wizard | | Twilio: SMS & voice | Env vars | guided wizard | | Buzz: agent-native team chat by Block; the agent is a first-class member | Nostr identity | guided wizard | | Web Chat: a Next.js browser app | none | eve add channel/web | | Custom: your own webhook / WebSocket | your code | New → Custom |

Vercel Connect channels (Slack, GitHub, Linear)

These run credentials through Vercel Connect: no SLACK_BOT_TOKEN for you to manage. The channel file references the connector, e.g.:

import { connectSlackCredentials } from "@vercel/connect/eve";
import { slackChannel } from "eve/channels/slack";

export default slackChannel({
  credentials: connectSlackCredentials("slack/my-agent"),
});

The connector must be attached with triggers pointed at Eve's route so the platform delivers events (see below). Slack has its own page: Connecting Slack.

Env-based channels (Discord, Teams, Telegram, Twilio)

These read credentials from environment variables. Each has a guided Set up wizard (bot creation, credentials, webhook or endpoint, ship) that tells you exactly which vars to set (e.g. DISCORD_PUBLIC_KEY, DISCORD_APPLICATION_ID, DISCORD_BOT_TOKEN; MICROSOFT_APP_ID, MICROSOFT_APP_PASSWORD; TELEGRAM_BOT_TOKEN, TELEGRAM_WEBHOOK_SECRET_TOKEN; TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN). Set them in Deploy → Environment, deploy, then use Finish setup on the configured row to register the webhook or verify the endpoint against the deployment.

Web Chat

Adds a Next.js Web Chat application so your agent has a browser UI. Enable it when you first create an agent, or add it later from the Channels catalog; Studio runs eve add channel/web --non-interactive --yes.

Buzz

Block's agent-native team chat. Studio's guided wizard gives a deployed agent its own Nostr identity, profile, and an inbound bridge; see Connecting Buzz, which also covers Eve's official ACP adapter for local agents.

Custom channels

For any surface Eve doesn't ship, author one with defineChannel from eve/channels. Route handlers receive from, attachSession, to, params, and waitUntil; from(address) binds a channel-local conversation address and starts or continues its session. Studio's New → Custom scaffolds this shape:

import { defineChannel, GET, POST } from "eve/channels";

export default defineChannel({
  routes: [
    POST("/threads/:threadId/messages", async (request, { from, params }) => {
      const body = await request.json();
      const session = await from(params.threadId).send(body.message, { auth: null });
      return Response.json({ sessionId: session.id });
    }),
    POST("/threads/:threadId/cancel", async (_request, { from, params }) =>
      Response.json(await from(params.threadId).cancel()),
    ),
    GET("/sessions/:sessionId/stream", async (_request, { attachSession, params }) => {
      const stream = await attachSession(params.sessionId).getEventStream();
      return new Response(stream, {
        headers: { "content-type": "application/x-ndjson; charset=utf-8" },
      });
    }),
  ],
  events: {
    "message.completed"(event, _channel, ctx) {
      console.log(ctx.session.id, event.message);
    },
  },
});

A route's path is its app URL (the channel filename does not prefix it), and the /eve/v1/* namespace is reserved. from(addr) also exposes respond, compact, clear, and reset; to(channel, target).send(message, { auth }) hands a conversation to another channel.

Adding a channel in Studio

Integrations → Channels has three sections:

  • Configured: the built-in eve HTTP channel (always on) plus every channel file in the agent, each with a status badge such as connected to this agent, not attached. Finish setup, or added, the connector it uses (bot slack/<uid>), and its route. Rows offer Finish setup when a deploy-side step is pending, Set up to reopen the wizard, and a Remove channel icon (which deletes the file; the connector stays attached in Vercel).
  • Add a channel: the guided grid, in order Slack, Discord, Microsoft Teams, Telegram, Twilio, GitHub, Linear, Buzz (each with Set up), then Web Chat and Custom (each with Add). Connect channels pick or create a Vercel Connect connector; env channels walk you through credentials and endpoints; Web Chat runs eve add channel/web --non-interactive --yes; Custom asks for a file name (default intake) and writes a defineChannel scaffold; Buzz runs the identity and bridge wizard.
  • More channels from the eve registry: a collapsed list of every other channel/* item the registry offers (Google Chat, WhatsApp, and more), each with a docs link and Install, which runs eve add channel/<name> --non-interactive --yes. Anything an item's setup needs from you is shown as a command to finish in a terminal.

Every path ends with agent/channels/<kind>.ts on disk. Set the environment variables the channel declares, then deploy: platform channels only reach the deployed agent.

Attaching a connector for triggers

For an event-driven channel, the platform needs to deliver events to Eve's route. Studio's Attach for triggers runs:

vercel connect attach <connector-uid> --triggers --trigger-path /eve/v1/<kind>

That re-points the connector's trigger destination at Eve's channel route (e.g. /eve/v1/slack). Then deploy so the live agent starts receiving events.

Next

  • Connecting Slack: the full Slack walkthrough.
  • Memory: Arcana and memory providers, also installed from the registry.
  • Deploy to Vercel: ship the agent so channels can reach it.
  • Hooks: observe results from connection tools.