Model Context Protocol, without the hosting

Give your agents the functions you already have.

Wrap the code you already run and it becomes an MCP server that Claude, Cursor and every other client can call. Your service dials out to us, so there is nothing to host, expose or put behind a tunnel.

Create a free account See how it works

Free to start
No inbound ports
Works with any MCP client

your agent dials out
a call goes in
the answer comes back

How it works

Three steps, and one of them is writing the handler.

1
Register the functions you have

Install the SDK in your service and wrap the functions you want to expose. They keep running in your process, next to your data and secrets.
2
Your service dials out

On start the agent opens one outbound connection to the gateway and announces its tools. It reconnects on its own if the network blips.
3
Clients call your project

Point any MCP client at your project's URL with a key. Each call is forwarded down the open connection, run by your code, and answered.

In your service

agent.ts

import { Agent, defineTool } from '@spacefix/core';
import { z } from 'zod';
import { orders } from './services/orders';   // code you already have

const agent = new Agent({ apiKey: process.env.SPACEFIX_API_KEY });

agent.register(defineTool({
  name: 'get_order',
  description: 'Look up an order by id',
  inputSchema: z.object({ id: z.string() }),
  handler: ({ id }) => orders.findById(id)
}));

agent.connect();   // dials out, no port to open

In a client

terminal

claude mcp add --transport http orders \
  https://api.spacefix.io/mcp/<project-id> \
  --header "Authorization: Bearer <client key>"

What the client gets

> tools/list
  get_order, search_orders, refund_order

> tools/call get_order {"id": "A-1042"}
  { "status": "shipped", "total": 4200 }
  // run by your service, in your network

Claude Code
Claude Desktop
Cursor
VS Code
MCP Inspector

Snippets for Claude Desktop, Cursor, VS Code and the MCP Inspector are generated for you on every project page.

What you get

Everything between a model and your function, handled.

Outbound only

Your service opens the connection. No ingress rule, tunnel or public endpoint to expose, and nothing to put behind a VPN.

A real MCP server

Tools, resources and prompts over Streamable HTTP, so Claude, Cursor, VS Code and any MCP client work without a custom integration.

See every call

Logs, a span waterfall per call, and latency percentiles per tool. Follow one request from the client, through the gateway, into your handler.

Your observability, not ours

The SDK speaks OpenTelemetry. Spans, metrics and logs go to Datadog, New Relic or Grafana, from your side. The gateway exports nothing.

Control the surface

Scoped keys, tool allow-lists, per-tool descriptions and caching for read-only calls, and webhooks when an agent goes offline.

Try it before clients do

Run any tool against your live agent from the dashboard and see exactly what a client would get back.

Trust boundary

Your code, data and secrets stay in your process.

The gateway never runs your code and has no way into your network. It knows the names and schemas of your tools, and it forwards a call down a connection you opened.

Keys are hashed A key is shown once, when it is created. Only a hash is stored, so a lost key is replaced, never recovered.
Call logs hold sizes, not payloads Logs record which tool ran, how long it took and how big the arguments and result were. Never their contents.
Scoped by design Agent keys register tools; client keys call them. Limit a key to the tools it needs, and revoke it on its own.
Two-factor and an audit trail Protect the account with a second factor, and see who changed what in the activity log.

Connect your first agent in a few minutes.

Create an account, make a project, paste the key into your service. The dashboard shows the connection the moment it opens.

Create a free account Sign in