330 tools in. About 20 in the menu. Every one still callable.
Real MCP clients cap the tool list. Claude's stack keeps the alphabetically-first 256 tools from a single MCP server and silently drops the rest — no error, no warning. The hub serves each server as one action-parameterised gateway tool, so the menu stays small and nothing behind it is lost.
The same server, configured three times.
Claude Desktop wants one shape. Cursor wants another. VS Code wants a third. You paste the same token into all of them, on both machines, and then a client quietly stops showing half your tools. Restarting does not fix it, because it is not a glitch — the client is cutting the list to a fixed size, in alphabetical order, every single time. Nothing errors. That is why it is so hard to name.
"command": "npx",
"args": ["-y", "…"], "env": { "GITHUB_TOKEN": "ghp_••••••••••" } } }
"type": "stdio",
"command": "github-mcp", "env": { "GITHUB_TOKEN": "ghp_••••••••••" } } }
"transport": "stdio",
"cwd": "~/tools", "env": { "GITHUB_TOKEN": "ghp_••••••••••" } } }
The failure is documented publicly against the client, not invented here: pagination on tools/list is ignored, and one server’s list is cut to its alphabetically-first 256 tools.
You don't build a config. You narrow a menu that already works.
Sign in and the project is already provisioned: two profiles, two live connections, twenty-one first-party services, and the catalog already granted — in full on Admin, and minus the tools that can spend money on Personal. There is no empty state to fill in. The work you do here is taking things away, not wiring things up.
$ claude mcp add --transport http parsons <your connection>
Get yours →
One connection · minted for you at sign-in. The --transport http flag is not optional — without it the CLI defaults to stdio and tries to execute the URL as a command.
One gateway per server. Unlimited grants behind it.
Instead of publishing 330 tool definitions and hoping your client keeps them, the hub publishes about twenty — one per server, named parsons_crm, parsons_money, parsons_storage. Each carries every action you have granted, as a parameter. The client's cap never gets near it.
The gateway's action list is the grant set — so narrowing the menu and narrowing permission are the same act. An action you have not granted is not in the list and is not callable by name.
If you prefer the flat listing, direct serving is a per-profile switch — and the default for a profile you create yourself — guarded at TOOL_BUDGET = 240 so it can never silently truncate on you. Past the budget the profile is flagged in the console and in show_profile rather than quietly losing tools.
{ action, args }
{ "action": "create_deal",
"args": { "title": "Acme renewal", "value": 4800 } }
routed through to crm · deal opened in the default business line✓ resolved at the service
{ "action": "delete_deal",
"args": { "deal_id": "dl_7f21" } }
Unknown action "delete_deal" on parsons_crm. Available actions: create_deal, list_contacts, log_activity, …✕ stopped at the hub — it never reaches crm
{ "action": "describe",
"args": { "action": "create_deal" } }
parsons_crm action "create_deal": Open a deal
(opportunity) in a business line…
Argument schema (pass as args):
{ "title": …, "business_line": …, "value": …,
"company_id": …, "contact_id": …, "stage": …,
"expected_close": … }
↩ answered by the hub, no service call spent
Hiding the tools doesn't make the model dumber.
It makes it faster to correct. When an argument name is wrong, most stacks let the upstream validator strip it silently and hand back an odd result, and the model guesses again. Here a wrong argument is refused loudly, with the complete schema inline, and the request is never sent.
This is not hypothetical. It is what PLAT-72 actually cost on one delete_bucket, and it is why the guard exists.
A tool you didn't grant isn't hidden. It isn't there.
No grant row means the tool is absent from tools/list and refused if the model calls it by name. Flip a switch and the change lands in an open session — the hub pushes tools/list_changed to every live session on that profile, so nobody has to reconnect.
The read / write / destructive tags come from the console itself. A tool's name is not its behaviour — which is why the grid shows what each one does, not only what it is called.
Turn delete_entry on and it appears here without a reconnect. Turn it off and calling it by name comes back refused, not empty.
Two things sit outside the switchboard.
Every product tool has a switch. Exactly two things do not, and neither is a rule somebody could later relax — they are shapes in the data model.
These are never written into the tool index, so the grants table has no row that could point at them. A managed profile cannot be given "change permissions" even by mistake. They live on a separate admin mount that requires the admin scope, and every mutation re-verifies project ownership against auth.
Every grant door funnels through one check, so the refusal lives in one place — and it names where the tool does belong instead of failing silently.
There is no "dangerous tool" blocklist here, because a blocklist is a list somebody forgot to update. Money, for one, has no transfer tool at all — so there is nothing to withhold.
Register any remote MCP server.
Three auth shapes, all shipped, no cap on how many. The hub holds the credential encrypted, discovers the server's tools on success, and re-checks health every hour. Your AI never sees a secret.
{ slug, name, url }
Nothing else needed. Point it at a public HTTPS Streamable-HTTP endpoint and its tools appear in your grant grid, alongside the twenty-one first-party ones, granted the same way.
{ slug, name, url, headerValue,
headerName? }
headerName defaults to Authorization. Rotate it later with hub__update_external_server and the tool list is re-discovered.
{ slug, name, url, scopes }
The hub discovers the provider and registers itself. Each teammate then connects their own account through a link the AI hands back — and can disconnect it with hub__disconnect_account.
The token you arrive with never travels upstream.
The hub does not issue tokens — auth.parsons.ai does, and the hub is an OAuth 2.1 resource server that validates them. When it calls a third-party server on your behalf it presents your own stored token for that server, and nothing else.
presented at: profile A
presented at: profile B
Audience binding (RFC 8707) means containment is by URL, not by a claim check somebody could misconfigure. Each connection also publishes RFC 9728 protected-resource metadata, so a compliant client discovers where to authenticate from the 401 itself.
Give someone six tools and ten dollars.
Role-based access answers may this person call this tool. It has no answer to how much may this person spend. We own the connection, the services and the ledger, so the cap is enforced where the money is — a monthly ceiling, in cents, that bounds everything their usage can charge you: AI tokens, metered usage and purchases alike.
profile Client Work · 30 tools
public channels bound to this profile: 1
— a phone line answers on this profile. Granting here publishes a tool to anyone who dials the number.
Who is on the team, what they hold, and who can approve a purchase.
Ask the owner to approve an over-budget purchase without ever seeing their contact details. Cap-exempt, because it is how you get unstuck — rate-limited to 10 a day per pair.
Membership is re-verified against auth on every single request — nothing is cached into session state, so removing a member bites on their very next message and their outstanding claim link dies with it. Admin and management profiles are never shareable with a member, structurally.
And when it can't check?
A profile can be the tool boundary for a public phone line — an assistant answers the number, and the assistant's tools are that profile's tools. Granting there publishes a tool to anyone who dials. The hub reads upward through the assistants binding before a grant lands.
Fails visible. "No channels" and "couldn't check" are never collapsed into the reassuring one.
| when | actor | tool | profile | result |
|---|---|---|---|---|
| 14:02 | sam | crm · create_deal | Client Work | ok |
| 14:01 | mike | hub__grant_tool | Client Work | ok |
| 14:00 | sam | crm · log_activity | Client Work | ok |
| 13:59 | mike | hub__revoke_tool | Client Work | ok |
| 13:52 | mike | hub__set_member_cap | — | ok |
A call the hub refuses is stopped before it reaches a service, so the log is what actually ran, not what was merely attempted. Read it from the console's Activity tab, or ask for it in chat with hub__recent_activity. Health is swept hourly with a confirming retry for platform servers, so an unhealthy connector is a fact in the console rather than a mystery in your client.
One sentence. Five real calls.
The hub administers itself over MCP. Everything on this page — profiles, grants, members, caps, third-party servers — is reachable from the AI you already use, and from the console's own chat if you would rather stay in a browser.
01 hub__create_profile applied
→ profile created, with its own endpoint. A profile you make yourself starts in direct serving.
02 hub__update_profile applied
→ switched to gateway serving · one tool per server, parsons_crm
03 hub__grant_server applied
→ 30 actions granted, 3 held back. All-or-nothing: if a name in except matches no tool, the whole call fails rather than granting more than you meant.
04 hub__add_member preview only — not sent
→ about to share 30 tools and 1 public channel. Re-send with confirm: true to send the invite and get the claim link.
05 hub__set_member_cap applied
→ $10.00 / month. 0 would be a hard lock.
Aliases and per-profile description overrides are part of hub__grant_tool too — rename a tool, or re-document it for one connection, without touching the upstream server.
The four rows we lose are the same size as the rest.
A comparison that only flatters the person who wrote it is a sales sheet. Here is the whole board.
| what you're checking | Parsons MCP Hub |
|---|---|
| Tool calls charged or capped | ✓No. Recorded, never billed, no monthly allowance — on every account. |
| Per-person monthly spend cap, in cents | ✓Yes — bounds AI, metered usage and purchases |
| Deny-by-default per-tool grants | ✓Yes — no grant row means absent from tools/list |
| Fits a client that caps at 256 tools | ✓Yes — ~21 gateway definitions, unlimited grants behind them |
| First-party services included | ✓21, in the same $15 subscription |
| Third-party servers, profiles, members | ✓Unlimited — no per-seat charge, and no cap exists in the code |
| Prebuilt third-party connectors | ✕None. You bring the server's URL. |
| Local / stdio MCP servers | ✕Remote HTTPS only. |
| Compliance attestations | ✕None. No SOC 2, no signed attestation to hand a procurement team. |
| Self-hosted or open source | ✕Managed only. |
| Audit retention | 90 days, then rotated out |
| Interactive widgets (ui:// resources) | Work for external servers. Platform services cannot serve one yet. |
If you need a thousand prebuilt SaaS connectors, a local stdio bridge, or a signed compliance attestation for a procurement review, buy the product that has them. If you need to hand a person an AI with a visible edge on both what it can do and what it can spend, that is the thing we built.
The meter is on. It just isn't wired to a price.
Every tool call is recorded and none is billed. There is no monthly allowance to run out of, and there will never be one — the old allowance rows were deleted because they had no reader, sat twenty times below real usage, and would have blocked the very tool a lapsed account needs to resubscribe.
Our own measured cost is $0.0000133 per call — 1.3¢ per thousand. That is why we can leave it free: the hub is the front door to twenty-one services you are already subscribed to, not the business itself.
Measured real load, for scale: the busiest hour we have seen from one account was 1,069 calls, and the heaviest single day ever was 1,376.
There is a front door pay-gate too, and it has the same shape: if a subscription lapses, subscribe, cancel, wallet and limits tools stay reachable from the agent, so you are never trapped needing a browser you do not have.
One plan. It covers everything.
The MCP Hub is not sold on its own. The subscription is the account, and the account is every Parsons product across unlimited projects. Pay monthly, or pay for the year and two of the twelve months are free. No per-seat line, no enterprise tier, no free tier.
- All 21 first-party services on one connection
- Per-member monthly spend caps, in cents
- 90-day audit log across every profile
- Auth monthly active users — also uncapped
- Scheduler 20,000 fires · Storage 5 GB · Email 200 sent/day
The hub itself is never the meter — tool calls stay free and uncapped, and the allowances live on the other products. Go past one of those and the overage simply draws from prepaid credits at roughly cost × 1.5: the bill starts when real usage does, not before.
Unlimited projects. At no extra cost.
A project is a hard wall: its own data, its own members, its own spend cap, and its own MCP connection. One per business, one for the side thing, one for personal. The price does not move.
cap $10/mo
cap $60/mo
cap $25/mo
cap $12/mo
cap $0/mo
Not per project. Not per seat.
Projects cost you organisation, not money — the subscription is the account, and it covers every project on it. Each one gets its own connection, so your client-work AI and your personal AI are not the same AI.
Is $15 worth it? Check it against one invoice.
Not against nothing — against the single tool you already pay for, and against the per-seat line that grows every time someone joins.
14-day free trial on your first subscription · cancel any time. The trial is a real subscription, so checkout does collect a card — and there is no free tier waiting behind it.
The awkward ones, answered flatly.
Will this fix my client dropping tools?
Which clients does it work with?
Can I connect my own MCP servers?
Can I share a profile by sending someone the link?
Can a teammate spend my money?
What happens if I hit the abuse ceiling?
How long do you keep the audit log?
Do you have SOC 2?
Is there a free tier?
Is there an annual plan?
How many projects can I have?
A small menu. Nothing missing behind it.
One connection, minted for you at sign-in — with a switch on every tool and a dollar cap on every person you hand it to.