---
title: "Install Integrations"
description: "Discover and install extensions and other integrations from eve and third-party sources."
contentType: "How-to"
---

Install integrations from eve's official catalog, a third-party source, or an integration URL. Integrations are distributed using the [shadcn registry format](https://ui.shadcn.com/docs/registry).

## 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.

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

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.

## Find an integration

Browse the [Integrations directory](/integrations) to see the official integrations available from the eve registry.

List every official integration and configured third-party source:

```bash
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:

```bash
eve registry search browser --limit 5
```

Inspect an integration before you install it:

```bash
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](https://skills.sh), available as the built-in `@skills` source.

## Add a skill

Add a known [skills.sh](https://skills.sh) item directly:

```bash
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:

```bash
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:

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

Install an integration from that source:

```bash
eve add @acme/analytics
```

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

```bash
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](https://github.com/vercel/eve/blob/main/CONTRIBUTING.md#adding-an-integration-to-the-registry) 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](#add-a-third-party-source). 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](https://ui.shadcn.com/docs/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:

```text
registry.json
registry/
└── analytics.ts
```

```json title="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:

```bash
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:

```bash
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:

```bash
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](./extensions) for mount configuration, namespacing, and overrides.

Provider-specific setup lives in the [Integrations directory](/integrations). 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:

```bash
eve add extension/agent-browser
```

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

```bash
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.

## What to read next

- [Extensions](./extensions): configure and override installed extension mounts
- [Integrations directory](/integrations): provider-specific setup and security guidance
- [shadcn registry documentation](https://ui.shadcn.com/docs/registry): publish a compatible third-party registry