Add Integrations

Discover and install extensions and other integrations from eve and third-party sources.

Install integrations from eve's official catalog, a third-party source, or an integration URL. Integrations are distributed using the shadcn registry format.

Install an integration

Run eve add from an eve agent project. This installs the integration's dependencies and writes its declared files into your project.

eve add extension/agent-browser
eve add linear
eve add instrumentation/braintrust

If an item is not found, eve add searches the available catalogs and prints close matches without installing anything.

If you do not know an item name yet, run eve add without an argument. Its help output shows how to search the registry with eve registry search <query>.

Extensions may create a mount under agent/extensions/. Connections write their initial definition under agent/connections/ and install @vercel/connect when required. Instrumentation providers write agent/instrumentation.ts; because an agent has one instrumentation file, compose multiple exporters there by hand. Configure generated files and required environment variables before running your agent.

Some integrations package several independently installable components. For example, eve add linear lets you choose the Linear Channel, Linear MCP, or both; both are selected by default. The specific eve add channel/linear-agent and eve add connection/linear commands remain available.

When an official item declares an interactive setup flow or flows, eve asks whether to run them after installation and runs multiple flows in declaration order. Run the printed eve add <item> --skip-install command to resume a skipped or cancelled setup later; it reruns the selected components' declared flows from the beginning.

For non-interactive automation, run eve add <item> --non-interactive. Add --yes to accept recommended setup values and reduce setup round trips; explicit --answer values take precedence. Eve returns structured component, setup-input, or prerequisite instructions instead of prompting. Use the continuation command in the response and add the requested answer; it adds --skip-install once registry installation has completed; resupply any prior answers from the calling agent's state. Pass non-secret answers with repeatable --answer 'key=<JSON value>' options. Supply secrets through the integration's documented environment variable or secret store rather than command-line arguments.

Find an integration

Browse the Integrations directory to see the official integrations available from the eve registry.

List every official integration and configured third-party source:

eve registry list

Search the catalog when you know what capability you need. Search returns up to 10 matches by default; use --limit to request between 1 and 100:

eve registry search browser --limit 5

Inspect an integration before you install it:

eve registry view extension/agent-browser

list includes the official eve catalog and every source you add to the project. search also includes skills.sh, available as the built-in @skills source.

Add a skill

Add a known skills.sh item directly:

eve add @skills/vercel-labs/agent-skills/vercel-react-best-practices

Skills from skills.sh are community-authored project files. Review their source and the resulting diff before you run your agent.

Add a third-party source

Use the integration URL template provided by the registry publisher and give the source a namespace:

eve registry add @acme=https://registry.acme.com/r/{name}.json

eve stores the mapping in package.json#registries. The {name} placeholder becomes the integration name, so @acme/analytics resolves to https://registry.acme.com/r/analytics.json.

Limit listing or search to that registry when needed:

eve registry list --registry @acme
eve registry search analytics --registry @acme

Install an integration from that source:

eve add @acme/analytics

Install a known integration URL directly when you do not need a namespace:

eve add https://registry.acme.com/r/analytics.json

Contribute an official integration

Community contributions to the official registry are welcome. Open an issue and get maintainer agreement before submitting a pull request, then follow the registry contribution guide for the required source files, metadata, validation, and extension requirements.

Host your own registry

Hosting your own registry is the publishing side of the third-party source workflow. Once it is deployed, other eve projects can give it a namespace and pull integrations from it.

An eve registry is a standard shadcn registry, so it can be hosted by any service that serves JSON over HTTP. It needs two kinds of endpoint:

A catalog such as https://registry.acme.com/r/registry.json for eve registry list and eve registry search
One JSON document per integration, such as https://registry.acme.com/r/analytics.json, for eve registry view and eve add

Start with a source file for the integration and a registry.json that describes where to install it:

registry.json
registry/
└── analytics.ts

registry.json

{
  "$schema": "https://ui.shadcn.com/schema/registry.json",
  "name": "acme",
  "homepage": "https://registry.acme.com",
  "items": [
    {
      "name": "analytics",
      "type": "registry:item",
      "title": "Acme Analytics",
      "description": "Add Acme analytics tools to an eve agent.",
      "dependencies": ["@acme/eve-analytics"],
      "envVars": {
        "ACME_API_KEY": ""
      },
      "files": [
        {
          "path": "registry/analytics.ts",
          "type": "registry:file",
          "target": "agent/extensions/analytics.ts"
        }
      ]
    }
  ]
}

files[].path is relative to registry.json. files[].target is relative to the root of the eve project that installs the item. Use registry:item with explicit registry:file targets for eve integrations so installation does not depend on a UI framework or shadcn project aliases.

Validate the source registry, then build its static JSON:

pnpm dlx shadcn@latest registry validate
pnpm dlx shadcn@latest build

By default, the build writes the catalog to public/r/registry.json and each item to public/r/<name>.json. Deploy the public directory to a static host, or use the shadcn registry APIs to serve the same payloads from dynamic routes.

Before sharing the registry, test its deployed catalog and item endpoints from an eve project:

eve registry list --registry https://registry.acme.com/r/registry.json
eve registry view https://registry.acme.com/r/analytics.json

Share the item URL template with consumers. From another eve project, they can add the hosted registry as a third-party source and pull the integration through its namespace:

eve registry add @acme=https://registry.acme.com/r/{name}.json
eve add @acme/analytics

Configure generated files

Integrations add project files. Read the generated mount before you run the agent, then add the configuration the extension requires.

For an extension, this usually means setting environment variables and editing the file under agent/extensions/. See Extensions for mount configuration, namespacing, and overrides.

Provider-specific setup lives in the Integrations directory. Follow that guidance for credentials, approval policies, and service-specific options.

Update an installed integration

Treat generated files as project code. Commit or review local changes before you install the integration again.

Run the same command when the registry publisher provides an updated scaffold:

eve add extension/agent-browser

Pass --overwrite only when you intend to replace an existing generated file:

eve add extension/agent-browser --overwrite

Update the installed package with your package manager. Check the publisher's release notes before changing the generated mount or package version.

Choose trusted sources

Integrations can add dependencies and write files. Add sources you trust, inspect an integration with eve registry view, and review the resulting project diff before you run the agent.

Frameworks

SDKs

Other