Antenna MCP
Antenna provides a Model Context Protocol (MCP) server that lets AI assistants and agents query your engineering metrics directly. Use natural language prompts to explore contributor productivity, AI tool adoption, team trends, and more.
The MCP server exposes read-only tools and returns structured JSON responses. It uses the Streamable HTTP transport.
Choose how to connect
There are two ways to authenticate with the Antenna MCP server.
| Sign in as yourself (OAuth) | Enterprise API key | |
|---|---|---|
| Who the connection represents | You | Your enterprise |
| Setup | Add the server URL and approve the request in your browser | An admin creates a key and you add it as a header |
| Data access | Only what your Antenna role and group access allow | The whole enterprise |
| Credentials to manage | None — tokens refresh and expire automatically | A long-lived key you store and rotate |
| Ends when | Your Antenna access changes or you revoke the connection | The key is revoked |
| Best for | People using an AI assistant (Claude, Cursor, Codex, Copilot, Devin) | Headless jobs, scripts, and shared agents that cannot open a browser |
Sign in as yourself is the recommended option. Your MCP client opens Antenna in your browser, you approve the requested access, and the client receives a token tied to your account. There is no key to copy, share, or rotate, and the connection stops working when your access to the enterprise expires.
Use an enterprise API key only when a browser sign-in is not possible (e.g., a cron job, CI pipeline, or another headless agent). Keep in mind that it reads data for the whole enterprise regardless of who uses it.
Both options expose the same tools. You can find your enterprise’s exact server URLs, manage your OAuth connections, and create API keys in your enterprise Settings at app.antenna.dev .
Connection details
No matter which client you use, you configure it with a server URL and, for API keys, an Authorization header. The setup instructions below reuse these values, so you can refer back to this section whenever a client asks for them.
The server URL depends on how you connect:
| Option | Server URL |
|---|---|
| Sign in as yourself (OAuth) | https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG |
| Enterprise API key | https://app.antenna.dev/api/mcp/enterprise |
The OAuth URL ends with your enterprise slug, while the API key URL does not. Your enterprise slug is the identifier in your Antenna URL; for example, acme in https://app.antenna.dev/enterprises/acme.
For authentication, the two options differ in how they use the Authorization header:
- OAuth: leave the
Authorizationheader empty. Antenna advertises OAuth discovery and dynamic client registration, so supported clients register themselves and start the browser flow for you. - API key: send the key as an
Authorizationheader:
Authorization: Bearer YOUR_API_KEYExample prompts
Once connected, you can ask your AI assistant natural language questions. The assistant will automatically select and call the appropriate MCP tools.
- “Who is spending the most on AI?”
- “Who used AI the most and least efficiently over the last 6 months?”
- “How can my team optimize AI spending?”
- “Whose PRs are taking the longest to be reviewed? Is there a correlation with PR size?”
- “Looking at the last 6 months, what are the biggest opportunities for improvement on my team?”
Prerequisites
- An Antenna enterprise account with the MCP feature enabled
- An active membership in the enterprise you are connecting to, if you sign in as yourself
- An enterprise API key, if you authenticate with a key
Create an API key
If you plan to authenticate with an enterprise API key, an enterprise admin needs to create one:
Sign in as an admin
Sign in to app.antenna.dev as an enterprise admin.
Open your API Keys settings
Go to your enterprise Settings > API Keys.
Create and copy the key
Click Create token, give it a description (e.g., “MCP Server”), and copy the key. The key is shown only once. Store it securely, as you will need it for each MCP client configuration below.
Available tools
The MCP server exposes the following read-only tools:
| Tool | Description |
|---|---|
contributor_metric_fields | Describe available metric fields, sort fields, date granularities, and result limits. |
enterprise_identity_groups | List identity groups (teams) available for filtering contributor metrics. |
enterprise_identity_search | Search enterprise identities by display name, username, email, or external account ID. |
contributor_metrics_list | Return contributor metrics for an enterprise over a bounded date range. |
contributor_metrics_trends | Return per-period contributor metrics for selected enterprise identities. |
When you sign in as yourself, Antenna grants the tools your role allows. Every member can read metrics; broader access, such as identity search, follows your role in the enterprise.
Setup
The Antenna MCP server works with most tools that support the Model Context Protocol. The sections below provide step-by-step instructions for some of the most popular clients, but this list is not exhaustive. You can connect most MCP-compatible tools using the same endpoints and authentication options.
Jump to the setup instructions for your AI assistant:
- Augment Code
- ChatGPT and Codex
- Claude Desktop and Claude Code
- Claude on AWS Bedrock
- Cursor
- Devin
- GitHub Copilot
- Kiro
- Microsoft 365 Copilot
Each section below covers signing in as yourself first, then the API key alternative where it applies. Replace YOUR_ENTERPRISE_SLUG with your enterprise slug and YOUR_API_KEY with an enterprise API key.
Augment Code
Augment Code configures MCP servers through its Settings Panel. It does not run the OAuth browser flow itself, so use mcp-remote to sign in as yourself. This requires Node.js .
Open the Augment Settings Panel
In the Augment panel (VS Code, JetBrains, or another supported editor), open the options menu in the upper right and click Settings. Scroll to the MCP servers section.
Add the Antenna server
Click Import from JSON and paste:
{
"mcpServers": {
"antenna": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG",
"--transport",
"http-only"
]
}
}
}Approve access
The first time the server starts, Antenna opens in your browser and asks you to approve the access the client needs. Approve it, and the connection stays signed in.
Verify the connection
Start an Agent conversation and ask a question like “Who is spending the most on AI?” to confirm Augment can call the Antenna tools.
To use an enterprise API key instead, point Augment at the API key endpoint with a header:
{
"mcpServers": {
"antenna": {
"type": "http",
"url": "https://app.antenna.dev/api/mcp/enterprise",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}ChatGPT and Codex
The ChatGPT and Codex desktop apps, as well as the Codex CLI, share MCP configuration and support OAuth for Streamable HTTP servers.
Antenna does not currently support the ChatGPT web app. Use the ChatGPT desktop app or Codex instead.
Open MCP settings
In the desktop app, open Settings and select Plugins. Click Add and choose Add MCP server.
Configure the server
Enter the following and leave the headers empty:
- Name:
Antenna - Type: Streamable HTTP
- URL:
https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG
Authenticate and verify
Save the server and navigate back to the MCPs tab. Select Authenticate next to Antenna in the server list, then approve access in the browser. In the composer, type /mcp to confirm Antenna is connected, and ask a question like “Who is spending the most on AI?” to verify the tools work.
For the Codex CLI, add the server in ~/.codex/config.toml (or a project-scoped .codex/config.toml for trusted projects). The ChatGPT and Codex desktop apps and the Codex CLI all read the same config.toml, so you only need to configure Antenna once.
[mcp_servers.antenna]
url = "https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG"
auth = "oauth"After updating config.toml, sign in from the terminal:
codex mcp login antennaTo use an enterprise API key instead, point Codex at the API key endpoint with a header:
[mcp_servers.antenna]
url = "https://app.antenna.dev/api/mcp/enterprise"
http_headers = { "Authorization" = "Bearer YOUR_API_KEY" }Claude Desktop and Claude Code
Both the Claude desktop app and Claude Code can sign in to Antenna as you.
In the Claude desktop app, add Antenna as a custom connector .
Open connector settings
Go to Settings > Connectors and click Add.
Add the Antenna server
Enter Antenna as the name and https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG as the remote MCP server URL, then click Continue.
Connect and verify
In the modal that appears, leave Authentication set to Sign in now and OAuth Client set to Register Automatically, then click Add. Click Connect and approve access in your browser. To confirm the connection, ask Claude a question like “Who is spending the most on AI?”.
Claude Code configures MCP servers from the terminal.
Add the Antenna server
In your terminal, run:
claude mcp add --transport http antenna \
https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUGAuthenticate
Start claude, run /mcp, select antenna, and choose Authenticate. Claude Code opens Antenna in your browser so you can approve access. You can also run claude mcp login antenna.
Verify the connection
Run claude mcp list to confirm the server is connected, then ask a question like “Who is spending the most on AI?” to verify the tools work.
To use an enterprise API key instead, add the API key endpoint with a header:
claude mcp add --transport http antenna \
https://app.antenna.dev/api/mcp/enterprise \
--header "Authorization: Bearer YOUR_API_KEY"Claude on AWS Bedrock
Claude on AWS Bedrock runs without a browser, so use an enterprise API key here.
Define the MCP server in your agent configuration
When creating or updating a Bedrock agent with MCP tool use, add the Antenna server to your tool configuration:
{
"mcpServers": {
"antenna": {
"url": "https://app.antenna.dev/api/mcp/enterprise",
"transport": "streamable-http",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}Configure in application code (Python example)
If you are invoking Claude on Bedrock programmatically with MCP tools, pass the server configuration when setting up your client:
mcp_servers = {
"antenna": {
"url": "https://app.antenna.dev/api/mcp/enterprise",
"transport": "streamable-http",
"headers": {
"Authorization": f"Bearer {ANTENNA_API_KEY}"
}
}
}Test the connection
Send a prompt that uses the Antenna tools (e.g., “List the identity groups in my enterprise”) to verify the integration is working.
Store the API key in a secrets manager rather than in source control, and rotate it on the same schedule as your other service credentials.
Cursor
Cursor supports OAuth for remote Streamable HTTP MCP servers.
Open Cursor settings
Go to Cursor Settings > Customize. Select New MCP Server.
Add the MCP server configuration
Add the server with a URL and no headers:
{
"mcpServers": {
"antenna": {
"url": "https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG"
}
}
}Sign in and verify
Save the file. Antenna appears in the MCP settings with a Needs Attention state. Click Authenticate and approve access in your browser. The Antenna tools then appear in the list, and you can ask questions about your engineering metrics in Agent mode.
To use an enterprise API key instead, point Cursor at the API key endpoint with a header:
{
"mcpServers": {
"antenna": {
"url": "https://app.antenna.dev/api/mcp/enterprise",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}Devin
Devin supports MCP servers through its web-based settings.
Open MCP settings
In the Devin web app, go to Settings > Connections > MCP servers and click Add a custom MCP.
Configure the server
Fill in the following and leave the headers empty:
- Server Name:
Antenna - Short Description:
Query engineering metrics from Antenna - Transport type: HTTP
- URL:
https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG
Authenticate and test
Save the server, then complete the OAuth flow in the browser window Devin opens. Click Test listing tools to confirm Devin can discover the Antenna tools.
Only users with the Manage MCP Servers permission can authenticate OAuth-based MCP servers in Devin. For Organization access, authenticate with an Antenna service account so every member’s session uses the same connection; with Personal access, sign in as yourself. See the Devin MCP documentation for details.
To use an enterprise API key instead, set the URL to https://app.antenna.dev/api/mcp/enterprise and add an Authorization header with the value Bearer YOUR_API_KEY.
Kiro
Kiro connects to remote MCP servers through its MCP configuration file. It does not run the OAuth browser flow itself, so use mcp-remote to sign in as yourself. This requires Node.js .
Open the MCP configuration
Open the Kiro panel, go to the MCP Servers view, and click Edit — or open the configuration file directly at .kiro/settings/mcp.json (workspace) or ~/.kiro/settings/mcp.json (user level).
Add the Antenna server
Add an entry under the mcpServers key:
{
"mcpServers": {
"antenna": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG",
"--transport",
"http-only"
]
}
}
}Approve access and verify
Save the file. Kiro reconnects automatically and Antenna opens in your browser so you can approve access. Ask a question like “Who is spending the most on AI?” to confirm Kiro can call the Antenna tools.
To use an enterprise API key instead, connect to the API key endpoint directly:
{
"mcpServers": {
"antenna": {
"type": "http",
"url": "https://app.antenna.dev/api/mcp/enterprise",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}GitHub Copilot
GitHub Copilot supports MCP servers in agent mode, and it handles the OAuth flow for you. Depending on where you work, you can use Antenna with Copilot in either of two tools:
- Visual Studio Code, where Copilot runs inside your editor.
- The GitHub Copilot desktop app, a standalone app for chatting with Copilot.
Both give you the same Antenna tools, so follow the instructions for the tool you use.
To use Antenna in Visual Studio Code, add the server through a .vscode/mcp.json configuration file. MCP support in GitHub Copilot requires a recent version of VS Code and is available in agent mode. See the GitHub Copilot MCP documentation for the latest details.
Create the MCP configuration file
In your workspace, create a file at .vscode/mcp.json (or run MCP: Add Server from the Command Palette and choose HTTP).
Add the Antenna server
Add an entry under the servers key, with no headers:
{
"servers": {
"antenna": {
"type": "http",
"url": "https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG"
}
}
}Start the server and verify
Click Start above the server entry in .vscode/mcp.json. VS Code opens Antenna in your browser so you can approve access. Then open the Copilot Chat view, switch to Agent mode, and ask a question like “Who is spending the most on AI?” to confirm Copilot can call the Antenna tools.
To use Antenna in the GitHub Copilot desktop app, add the server through the app’s MCP settings.
Open the MCP settings
Open the desktop app, navigate to Customize, and select the MCP tab. Click Add > MCP server.
Configure the server
Enter the following:
- Server name:
antenna - Select HTTP
- URL:
https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG
Click Add server. The Antenna MCP now appears in the list of installed MCPs.
Sign in and verify
Click the Sign in button next to the newly added Antenna server, and follow the authentication steps in your browser. Once connected, ask a question like “Who is spending the most on AI?” to confirm Copilot can call the Antenna tools.
To use an enterprise API key instead, point the server at https://app.antenna.dev/api/mcp/enterprise and add an Authorization header with the value Bearer YOUR_API_KEY.
Microsoft 365 Copilot
To use Antenna in Microsoft 365 Copilot, you first build an agent in Copilot Studio, then use that agent inside Microsoft 365 Copilot (or Teams). You connect Antenna as a tool on the agent, test the agent in Copilot Studio, and then publish it to Microsoft 365 Copilot so you and your organization can chat with it there.
Antenna connects as a tool and supports OAuth 2.0 with dynamic discovery. Your agent must use generative orchestration, which new agents use by default.
Create an agent
In Copilot Studio, create a new agent (or open an existing one) that will surface in Microsoft 365 Copilot. New agents use generative orchestration by default. To confirm, open the agent’s Settings, and under Generative AI > Orchestration, make sure Use generative AI orchestration for your agent’s responses? is set to Yes. MCP tools only work with generative orchestration.
Add a new tool
Go to the agent’s Tools page and select Add a tool > New tool > Model Context Protocol. Enter the following:
- Server name:
Antenna - Server description:
Query engineering metrics from Antenna - Server URL:
https://app.antenna.dev/api/mcp/enterprise/YOUR_ENTERPRISE_SLUG
Select OAuth 2.0 as the authentication method, then choose Dynamic discovery. Antenna publishes its OAuth metadata and registers your client automatically, so there is no client ID or secret to enter.
Create the tool and connect
Select Create, then create a new connection when prompted and complete the Antenna sign-in and consent in the browser. Select Add to agent to add the Antenna tool to your agent.
Test the agent in Copilot Studio
In the Test pane, ask a question like “Who is spending the most on AI?” to confirm the agent can call the Antenna tools. If you see a cached answer, start a new test session and try again.
Publish the agent to Microsoft 365 Copilot
The test pane only verifies the agent while you build it. To use your new agent, publish the agent to Microsoft 365 Copilot:
- Select Publish.
- Open the Channels tab, select Teams and Microsoft 365 Copilot, and confirm Make agent available in Microsoft 365 Copilot is selected.
- Submit the agent for admin approval (for example, Availability options > Show to everyone in my org). An enterprise admin approves it in the Microsoft 365 admin center under Agents > All agents > Requests.
Once approved, the agent appears in the Microsoft 365 Copilot Agent Store under Built by your org. Open Microsoft 365 Copilot, select or @mention the agent, and ask about your engineering metrics.
For Microsoft’s reference documentation, see Extend your agent with Model Context Protocol , Add an existing MCP server to an agent , and Extend Microsoft 365 Copilot with agents built in Copilot Studio .
Managing connections
Each client you sign in from creates its own connection. Review your connections and revoke any you no longer use in the MCP Server section of your enterprise Settings. Revoking a connection immediately stops that client from calling Antenna; sign in again from the client to restore it.
Troubleshooting
| Issue | Solution |
|---|---|
401 Unauthorized (OAuth) | Sign in again from your client. Confirm the server URL ends with your enterprise slug and that you still have an active membership in that enterprise. |
401 Unauthorized (API key) | Verify the key is correct and has not been revoked. Regenerate it in Settings > API Keys if needed. |
| Client never opens the browser | Remove any Authorization header from the configuration — a manually supplied header takes precedence over OAuth. Clients without built-in OAuth support need mcp-remote. |
403 Forbidden | The MCP feature may not be enabled for your enterprise, or your role may not include the requested access. Contact your enterprise admin or your Antenna account representative. |
| Tools not appearing | Restart your AI client after updating the configuration. Ensure the URL matches the option you chose — the OAuth endpoint includes your enterprise slug, the API key endpoint does not. |
| Empty results | Check your date range and filters. The default range is the last 6 months. Use contributor_metric_fields to see available options. |