# Use DevTune with Eve

Canonical: https://devtune.ai/integrations/eve

Connect Eve to your DevTune project, then ask it what AI platforms say about your product, what to fix next, and whether a shipped fix moved the numbers.

## Before you start

- A DevTune project on a plan that includes API access. No account yet? [Let your agent set one up](https://docs.devtune.ai/getting-started/agent-setup).
- An Eve agent project. These steps add DevTune as a connection the agent can call.
- A project API key from **API Keys** in the account sidebar. DevTune shows the key once, so copy it when you create it.

## Connect with an API key

Your Eve agent connects with a project API key.

Set `DEVTUNE_API_KEY` in the environment of the deployment that runs the agent, then create `agent/connections/devtune.ts`. The filename becomes the connection name:

```ts
import { defineMcpClientConnection } from 'eve/connections';

// Tools that change your project or spend credits. A person approves each call.
const NEEDS_APPROVAL = [
  'devtune_change_action_status',
  'devtune_generate_action_brief',
];

export default defineMcpClientConnection({
  url: 'https://devtune.ai/api/mcp',
  description:
    'DevTune: what AI platforms say about the product, who they cite, AI traffic to the site, ranked fixes and measured results.',
  auth: {
    credentialOwner: 'app',
    getToken: async () => ({ token: process.env.DEVTUNE_API_KEY! }),
  },
  tools: {
    allow: [
      'devtune_get_connection_context',
      'devtune_get_visibility_summary',
      'devtune_get_visibility_diff',
      'devtune_get_competitive_position',
      'devtune_get_top_citation_pages',
      'devtune_get_content_gaps',
      'devtune_get_traffic_summary',
      'devtune_get_404_demand',
      'devtune_get_actions',
      'devtune_get_action_brief',
      'devtune_get_outcomes_ledger',
      ...NEEDS_APPROVAL,
    ],
  },
  approval: ({ toolName }) =>
    NEEDS_APPROVAL.some((tool) => toolName.endsWith(tool))
      ? 'user-approval'
      : 'not-applicable',
});
```

Eve sends the key as `Authorization: Bearer <key>` on every request. Write the `description` for the model. The agent searches it when it decides which connection to use.

A key reaches the one project it was created for, with the scopes you gave it. A change made with a key acts as the member who created it.

## Check the connection

Ask the agent which DevTune project it is connected to. It finds the tool through `connection_search` and calls `devtune__devtune_get_connection_context`.

Then ask your Eve agent:

```text
Which DevTune project are you connected to?
```

It answers with your project's name, read with `devtune_get_connection_context`. If it names the wrong project, connect again and select the right one.

## Measure

Ask your Eve agent what AI platforms say and what AI systems fetch from your site:

```text
What is our share of voice across AI platforms over the last 30 days, and how has it changed?
```

```text
Which pages and domains do AI platforms cite for our topics, and which competitors get cited where we are not?
```

```text
What are AI systems fetching from our site, and which pages do they ask for that do not exist?
```

Your Eve agent answers from `devtune_get_visibility_summary`, `devtune_get_visibility_diff`, `devtune_get_competitive_position`, `devtune_get_top_citation_pages`, `devtune_get_content_gaps`, `devtune_get_traffic_summary` and `devtune_get_404_demand`. Measurement windows are 30 or 90 days.

## Fix

Ask for the ranked fixes, then work one through:

```text
List the top five actions DevTune suggests for this project, with the evidence behind each.
```

```text
Accept the first action, generate its brief and show me the brief.
```

```text
Mark that action live. The page is published at https://example.com/your-page.
```

1. `devtune_get_actions` lists the queue with its evidence.
2. `devtune_change_action_status` accepts an action, and `devtune_generate_action_brief` writes its brief. Generating a brief spends credits.
3. Your Eve agent reads the brief with `devtune_get_action_brief`. Writing and publishing the page is your work and the agent's, in your own repository or content system. DevTune drafts and never publishes.
4. `devtune_change_action_status` with `mark_live` and the published URL starts the before/after measurement.

## Prove

```text
Which of our shipped actions have results, and what moved?
```

`devtune_get_outcomes_ledger` returns each measured action as improved, mixed, no clear change, declined, still measuring or unmeasured. Results show what moved after a fix shipped, not what caused it. Results windows are 7, 30, 90 or 365 days.

## What needs your approval

- Reading never changes your project or spends credits.
- Accepting an action, changing prompts or competitors, and every other change acts as you. Have the agent say what it will change before it does.
- Briefs, drafts, managed-agent runs, Agent Picks tests and prompt-set analysis spend credits. Approve the spend before the agent starts one.
- DevTune steers suggestions around locked pages and says when it did.

## How Eve runs DevTune tools

Eve names the tools `devtune__<tool>`. `tools.allow` lists the only tools the model can discover. The list above covers the measure, fix and prove steps on this page. The `approval` policy pauses the agent for a person before it accepts an action, marks one live or generates a brief, and lets the read tools run without a prompt. Add any other tool that changes your project to both lists.

## Limits

- The agent can use only the tools in `tools.allow`. For a read-only agent, remove the two tools in `NEEDS_APPROVAL` from the list. It can then measure, read briefs and read results, and cannot accept an action or generate a brief.
- Eve passes a tool's whole result to the model. Ask DevTune for a narrower window or fewer rows when a result is too large.
- A connection reaches one project. Connect again, or use another key, for a second project.
- Tools your connection has no scope for do not appear in the agent. A connection never gains scopes added later. Edit the key, or disconnect and sign in again.

## If something goes wrong

| Symptom                                            | What to do                                                                                                                                                                        |
| -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Your Eve agent lists no DevTune tools              | Check the connection as described above. With an API key, confirm the key is active under **API Keys** and has not expired.                                                       |
| A tool is missing, or a call is refused with `403` | The connection lacks that tool's scope, or the plan lacks the feature. Ask the agent which scopes the connection has, then edit the key or sign in again with the scope selected. |
| Changes are refused but reads work                 | The connection has read scopes only, or the project is paused. Add the scope to the key or sign in again with it selected; resume a paused project in DevTune.                    |
| A figure comes back empty or as `Unmeasured`       | DevTune has no measurement for that window. Report it as unmeasured, not as zero.                                                                                                 |

## Next steps

- [Eve documentation](https://eve.dev/docs/connections): how Vercel documents connecting outside tools
- [MCP server](https://docs.devtune.ai/api-reference/mcp-server): every tool, its inputs and its scope
- [Code mode](https://docs.devtune.ai/api-reference/mcp-server#code-mode): two tools in place of the full list, for agents short on context
- [API authentication](https://docs.devtune.ai/api-reference/authentication): keys and scopes
- [Use DevTune with your agent](https://devtune.ai/integrations): setup guides for other agents