MCP server

Add the server

claude mcp add --transport http deliverd https://deliverd.dev/api/mcp

Claude Code opens a browser the first time it is used, so you can pick the organisation and approve access.

Add the server

codex mcp add deliverd --url https://deliverd.dev/api/mcp

Approve it in your browser

codex mcp login deliverd

Codex needs this second step — it does not begin the approval flow on its own.

On an older Codex

Streamable HTTP servers are only picked up when the rmcp client is on. If the server does not appear, upgrade Codex, or add [features] experimental_use_rmcp_client = true to ~/.codex/config.toml above the server entry.

Or add it to ~/.cursor/mcp.json

{
  "mcpServers": {
    "deliverd": {
      "type": "http",
      "url": "https://deliverd.dev/api/mcp"
    }
  }
}

Keep any servers already listed there — replacing the file removes them.

Reload Cursor

Then approve the connection in your browser.

Or add it to .vscode/mcp.json

{
  "servers": {
    "deliverd": {
      "type": "http",
      "url": "https://deliverd.dev/api/mcp"
    }
  }
}

In the project for one repository, or in your user settings for all of them. The key is “servers” — VS Code ignores an “mcpServers” block.

Start it

Run “MCP: List Servers” from the command palette, start the server, and approve the connection in your browser.

Turn on developer mode

Settings → Apps → Advanced settings → Developer mode. Custom connectors need a paid ChatGPT plan.

Add a custom connector with this address

https://deliverd.dev/api/mcp

The connector registers itself and sends you to a screen where you choose the organisation and approve access.

Settings → Connectors → Add custom connector

https://deliverd.dev/api/mcp

Add it to ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "deliverd": {
      "serverUrl": "https://deliverd.dev/api/mcp"
    }
  }
}

Keep any servers already listed there. The key is “serverUrl” — a plain “url” is ignored.

Refresh the servers

In Cascade's MCP panel, refresh, then approve the connection in your browser.

Add the server

gemini mcp add --transport http deliverd https://deliverd.dev/api/mcp

Approve it

/mcp auth deliverd

Inside Gemini, if it has not already opened a browser for you.

Add the server

npx deliverd setup --agent muse-code --url https://deliverd.dev

Writes the entry below into Muse Code's settings, keeping every server already there and a backup of the file.

Or add it to ~/.config/muse/settings.json

{
  "schema_version": 1,
  "mcp_servers": {
    "deliverd": {
      "transport": "streamable_http",
      "url": "https://deliverd.dev/api/mcp",
      "mode": "optional"
    }
  }
}

Keep schema_version and any servers already there. If your file says “mcpServers” rather than “mcp_servers”, add it under that key instead: a file with both turns every server off.

Approve it in your browser

muse mcp login deliverd

Then start a new session; /mcp lists the server and its tools.

Issue a key for the agent

Agents → Agents → the agent → Credentials → Issue new key. Its requests are then the agent's, under the permissions you gave it. Agent identities are on Team and above.

Keep it in a key-based connection in your Foundry project

Authorization: Bearer dlv_…

One key named Authorization whose value is the word Bearer, a space, and the key. Foundry sends it as a header on every call to the server.

Add the MCP tool to the agent

from azure.ai.projects.models import MCPTool

MCPTool(
    server_label="deliverd",
    server_url="https://deliverd.dev/api/mcp",
    require_approval="always",
    project_connection_id=connection.id,
)

With require_approval "always", Foundry pauses before each call with an mcp_approval_request. run_with_deliverd_approvals from deliverd.adapters.foundry (the Python SDK, from 0.11.0) asks a person in Deliverd and answers it.

Issue a key for the agent

Agents → Agents → the agent → Credentials → Issue new key. Its requests are then the agent's, under the permissions you gave it. Agent identities are on Team and above.

Keep it in AWS Secrets Manager

Read it into the agent's environment at start-up, as DELIVERD_KEY in the code below. The agent's execution role needs secretsmanager:GetSecretValue on that one secret.

On AgentCore, or anywhere Strands runs: add the MCP server

from mcp.client.streamable_http import streamablehttp_client
from strands import Agent
from strands.tools.mcp import MCPClient

deliverd_mcp = MCPClient(lambda: streamablehttp_client(
    "https://deliverd.dev/api/mcp",
    headers={"Authorization": f"Bearer {DELIVERD_KEY}"},
))
with deliverd_mcp:
    agent = Agent(tools=deliverd_mcp.list_tools_sync())

The agent can now call request_approval before it acts, and wait for the answer. To have a person decide the agent's own tool calls instead, add DeliverdApprovals from deliverd.adapters.strands to its hooks (the Python SDK, from 0.19.0).

On Bedrock Agents: confirm action group calls

from deliverd.adapters.bedrock import invoke_with_deliverd_approvals

Turn on user confirmation for the functions that matter, and Bedrock hands control back before each call. invoke_with_deliverd_approvals invokes the agent, asks a person in Deliverd about each call, and sends CONFIRM or DENY, with their reason, on the same session (from 0.19.0).

Issue a key for the agent

Agents → Agents → the agent → Credentials → Issue new key. Its requests are then the agent's, under the permissions you gave it. Agent identities are on Team and above.

Keep it in Secret Manager

Pass it to the agent as DELIVERD_KEY when you deploy it to Agent Engine, from Secret Manager rather than as plain text.

Add the MCP server to the agent

from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset

deliverd_mcp = McpToolset(connection_params=StreamableHTTPConnectionParams(
    url="https://deliverd.dev/api/mcp",
    headers={"Authorization": f"Bearer {DELIVERD_KEY}"},
))
agent = LlmAgent(model="gemini-2.5-flash", name="ops", tools=[deliverd_mcp])

The agent can now call request_approval before it acts, and wait for the answer. Deploy it to Agent Engine as you would any ADK agent.

Or have a person decide the agent's tool calls

from deliverd import Deliverd
from deliverd.adapters.adk import deliverd_before_tool_callback

agent = LlmAgent(..., before_tool_callback=deliverd_before_tool_callback(Deliverd()))

Each tool call waits for a person in Deliverd; a declined call does not run, and the model reads why. For tools built with require_confirmation, run_with_deliverd_confirmations answers ADK's confirmation from your client instead (the Python SDK, from 0.19.0).