One MCP endpoint for every agent.

What it does that a plain proxy does not

01Quickstart

The repository ships a working example: two MCP servers, three clients, nothing to install and no network needed.

git clone https://github.com/PabloPC05/jackfield && cd jackfield
npm install && npm run build

# does everything connect?
node packages/cli/dist/bin.js check  -c examples/jackfield.yaml
# what does each client load, and what does it cost?
node packages/cli/dist/bin.js tools  -c examples/jackfield.yaml --by-source
# what to paste into each agent
node packages/cli/dist/bin.js routes -c examples/jackfield.yaml
node packages/cli/dist/bin.js serve  -c examples/jackfield.yaml

Point an agent at it

# any client that can send a header
https://gateway.example.com/mcp
Authorization: Bearer <key>

# clients that cannot send headers (the key is then part of the secret)
https://gateway.example.com/k/<key>/mcp

See the cost before you pay it

$ jackfield tools --by-source

source    tools  definitions  tokens (rough)
--------  -----  -----------  --------------
porkbun     120  191 KB       ~48,900
github       49  137 KB       ~35,100
coolify      77   71 KB       ~18,200
memoria      15   14 KB        ~3,600

505 tools, 713 KB of definitions, about 182,000 tokens
for "claude-code" if the client loads them all.

That is the number expose: search and transport: cli exist to bring down.

02jackfield.yaml

The whole gateway is one file. No database, no admin panel writing state behind your back. Secrets are referenced, not embedded, and anything resolved from ${env:…} or ${file:…} is registered for redaction so it cannot reach a log line.

upstreams:
  github:
    transport: http
    url: https://api.example.com/mcp
    token: ${file:secrets/github.token}

  notes:
    transport: stdio              # a child process
    command: npx
    args: ["-y", "some-mcp-server"]

  porkbun:
    transport: cli                # 120 definitions → 1 tool
    commands:
      porkbun:
        description: "Porkbun CLI. Ask it for --help first."
        executable: porkbun
        allowedSubcommands: ["domain", "dns"]

  vault:
    transport: http
    url: https://vault.example.com/mcp
    oauth:                        # jackfield login vault, once
      scope: "read write"

  browser:
    transport: executor           # on a machine of yours
    executor: home

executors:
  home:
    attach: true                  # it dials us; no inbound port
    token: ${file:secrets/executor.token}

permissions:                   # a floor every client inherits
  - tools: ["*.delete_*"]
    action: ask                   # asks the user, not the agent
    via: link                     # on a page, even if nobody is watching

profiles:
  core: { upstreams: ["tag:personal"] }
  full: { extends: [core], upstreams: ["*"] }

clients:
  laptop:
    key: ${file:secrets/key-laptop}
    profile: full

  web-agent:
    key: ${file:secrets/key-web}
    keyInPath: true               # /k/<key>/mcp
    profile: core

  thrifty:
    key: ${file:secrets/key-thrifty}
    profile: full
    expose: search                # find_tool + call_tool

Full reference →

03Protocol behaviour

The cases that decide whether a gateway works in practice, and what Jackfield does with each.

04Features

Everything the gateway does. Filter or search; open a row for the detail.

05Deploy

The HTTP layer is written against Web Request/Response, so the gateway runs wherever you want it. What a given host cannot do — child processes, a browser, a shell — a Jackfield executor on a machine you own does, and the core reaches it with transport: executor.

06Compared

What each project in this space is built around, from its own documentation (November 2026). Pick by what you need, not by a feature count.

Status

Jackfield is new: written in November 2026, covered by its test suite, not yet battle-tested over months. Interfaces may change before 1.0. It deliberately has no container isolation, and its web view (/status) only reads — the file is the state, so a change stays a diff you can review.