Sign in Get started

The MCP gateway for AI agents

One MCP to rule them all.

Add your tools to Toolkien once and use them from every AI client. Your agent writes one script instead of forty tool calls: far fewer tokens, much faster runs.

Start free Self-host it

Free during early access · Open source under AGPL-3.0

Diagram: GitHub, Linear, Notion, Sentry, Stripe and Supabase are added to Toolkien once, and every AI client (Claude, ChatGPT, Codex, Cursor and VS Code) reaches them through one connection. In code mode a client sends one script; Toolkien runs it and makes a call to each tool, then returns one answer.
githublinearnotionsentrystripesupabaseClaudeChatGPTCodexCursorVS Code

Works with

  • Claude
  • Claude Code
  • ChatGPT
  • Codex
  • Cursor
  • VS Code
  • any MCP client

Early access: your team could be the first logo here.

Code mode

Far fewer tokens. Much faster runs.

Classic tool calling loads every schema and sends the whole context back to the model after each call. With Toolkien the agent reads only the types it needs and chains the calls in one script.

  • Classic tool calling

    Every call is a round trip

    Model round trips
    40
    Tokens (schemas + re-sent context)
    ~180k
    Wall time
    ~4 min

  • Code mode with Toolkien

    One script chains the calls

    Model round trips
    3
    Tokens (types it asked for)
    ~12k
    Wall time
    ~25 s

Illustrative example, not a benchmark: one triage task across GitHub, Linear and Slack (40 tool calls). Real measurements are on the way.

How it works

One tool to find them, one sandbox to run them.

Three tools do the work. The agent only loads what it needs, so long tool lists stop eating its context.

  1. 1 tools_search

    Search

    The agent searches your workspace’s tools by text and gets back paths with a one-line summary, not hundreds of schemas.

  2. 2 tools_describe

    Describe

    It reads compact TypeScript declarations of the few tools it needs, generated from each server’s schemas.

  3. 3 execute

    Execute

    It runs one script in an isolated sandbox that chains every call. Each call checks permissions; writes can wait for you.

What your agent runs
// What your agent sends to execute: one script, many calls
const issues = await github.listIssues({ repo: 'acme/web', state: 'open' });
const urgent = issues.filter((issue) => issue.labels.includes('p0'));

await slack.postMessage({
  channel: '#triage',
  text: `${urgent.length} urgent issues today`
}); // "ask" permission: you approve this call first

Connect once

Add a tool once. Use it from every client.

Company and personal tools live in one place. Claude, ChatGPT, Codex, Cursor and VS Code all reach them through one connection, in parallel, and a new tool shows up in all of them.

  • Without Toolkien

    Every tool, in every client

    Setups to maintain (5 clients × 6 tools)
    30
    Sign-ins to renew
    30

  • With Toolkien

    Each tool once, each client once

    Setups to maintain (6 tools + 5 clients)
    11
    Sign-ins to renew
    6

Add a tool and it shows up in every client at once; remove it and it is gone everywhere. Clients run in parallel on the same workspace.

Directory

Pick a tool. It's connected in a minute.

Official remote MCP servers, ready to add: choose one, sign in, and every AI client you use can reach it.

Directory

Pick a tool to connect

100 popular remote MCP servers, checked and preconfigured. Pick one, sign in, and every AI agent you use can work with it through Toolkien.

Browse all 100 tools

You sign in to each tool with your own account.

For teams

Share company tools, not tokens

A company workspace gives colleagues the same tools, under the rules you set, with every call on the record.

  • Company workspaces

    Admins connect shared accounts once; colleagues use them from their own clients without ever seeing a token.

  • Policy and permissions

    Allow, ask or block per tool, with floors members cannot loosen. Choose whether personal tools or free URLs are allowed.

  • Approvals and audit

    Writes wait for a human. Everyone sees their own timeline; admins see all of it and export CSV.

  • Kill switch

    Stop a workspace in one click: running scripts end, tokens are suspended, configuration stays.

Security

Built to be trusted with your keys

Toolkien sits between your agent and your services. It keeps only what it needs: accounts, encrypted credentials, configuration and metadata logs.

  • Encrypted credentials

    Upstream tokens are sealed with AES-256-GCM and a per-workspace key wrapped by OpenBao. A stolen database reveals no token.

  • Sandboxed scripts

    A fresh Deno process with no permissions per execution: no network, no environment, no filesystem. Only the tools you allowed.

  • Approvals come from you

    Approvals are never taken from the model. Writes ask by default; you decide per call or per script.

  • No token passthrough

    The token your client holds is never forwarded upstream. OAuth 2.1 with PKCE, audience-bound short-lived tokens.

  • Egress control

    Upstream calls leave through a dedicated proxy, https only, with private and metadata addresses blocked.

  • Metadata-only logs

    Who did what and when, never arguments, results or script code. Kept 90 days, then deleted.

Managed or self-hosted

Ours to run, or yours

The managed service is the easy path. Self-hosting gives you the same product on your own server.

  • Recommended

    Managed

    Sign up, add your first tool, connect your client. We run the rest.

    • Free during early access
    • Key vault, sandbox, egress proxy and updates handled for you
    • Company workspaces with invites, roles and audit
    Start free

  • Open source · AGPL-3.0

    Self-hosted

    The same product on your own server, as one Docker Compose stack.

    • App, OpenBao, egress proxy and runner in one compose file
    • Ready for Coolify, works anywhere Docker runs
    • Your database, your keys, your network
    docker compose up -d
    Self-hosting guide Source code

Connect once. Call them all.

One connection per client. Switch workspaces when you ask to, and always see where your agent is operating.

Create a free account Read the docs