Open Source · v0.1.0

The control plane
AI agents have always
needed.

Connect any API, database, or repo. Auto-generate a secure MCP server in seconds. Every agent action — observed, governed, and auditable. Your GPU. Your cloud. Your rules.

Watch the Demo View on GitHub
$0
Per token cost
<10ms
Gateway overhead
100%
Data stays in your cloud
Apache 2
License
The Problem

A question nobody could answer

There is a moment every engineering team reaches. Their AI agents are live. Things are working. And then someone asks a question that nobody has a good answer to:

"What exactly did the agent do last Tuesday?"

Nobody knows. The logs are incomplete. The tool calls went out through three different SDKs. The credentials were hardcoded somewhere upstream. The agent deleted a record in production and nobody got a notification. The compliance team is asking for an audit trail. The security team is asking why prompts are being sent to an external API.

This is not an edge case. This is the default state of almost every production AI agent deployment in the world today. The frameworks that build agents are excellent. The protocols that connect them to tools are maturing fast. But the layer in between — the layer that watches, governs, and accounts for everything that passes through — that layer does not exist anywhere else.

Until now.

"We spent four months building our own logging middleware, approval workflows, and rate limiting before we realized we were building infrastructure instead of product."

— The internal postmortem of every enterprise AI team, everywhere, right now.
What It Does

Every capability you'd build,
already built.

Synapse Relay is the answer every team builds separately, built once, correctly, and given away free.

⚙️
MCP Auto-Generator
Submit an OpenAPI spec, a Postgres connection string, or a GitHub repository URL. The model — running on your GPU, at zero cost — generates a complete, production-ready MCP server in seconds. One endpoint URL. Works in Claude Desktop, Cursor, any MCP client.
🔭
Full Observability
Every tool call is captured with timestamp, tool name, redacted inputs, redacted outputs, latency, token counts, trace ID, and policy result. The live dashboard streams new calls via WebSocket in real time. The audit log is paginated, searchable, and permanent.
🛡️
Policy Engine
Open Policy Agent evaluates every call against your Rego rules before it goes anywhere. Allow, deny, or require approval — per tool, per tenant, per client. The rules are code. They're version-controlled. They're auditable.
🔒
PII Redaction
Microsoft Presidio scans every input and output before it touches a log. Emails, phone numbers, SSNs, credit cards, IP addresses — all detected, all replaced with redacted tokens. Raw PII never reaches your database. Regex fallback ensures this works even when Presidio is unavailable.
✋
Human-in-the-Loop Approvals
Destructive actions — deletes, payments, transfers — are held at the gateway until a human approves or denies them from the dashboard. The agent waits. The tool is not called. The action is either completed or cancelled, with a full record either way.
⚡
vLLM Model Serving
Qwen2.5-Coder-32B-Instruct runs on your GPU via vLLM — the fastest open-source LLM inference engine in existence. PagedAttention, continuous batching, tensor parallelism for multi-GPU. The cost of every code generation request is the amortized cost of your hardware.
🔌
Connector Hub
One-click import from Composio and Zapier NLA turns any connected app into an MCP server instantly. Every imported connector shows up in the registry with enable/disable control. The bridge from existing integrations to the MCP world.
🏢
Multi-Tenant RBAC
Organizations are fully isolated. Per-tenant rate limits, per-tenant OPA policy overrides, per-tenant audit logs. Four roles — owner, admin, developer, viewer — with appropriate permissions at every layer. Enterprise-ready from day one.
☸️
Kubernetes Native
Helm chart with Bitnami PostgreSQL and Redis subcharts. Horizontal Pod Autoscalers on the gateway and API. GPU-aware vLLM deployment with tensor parallel configuration. Runs on EKS, GKE, AKS, or any CNCF-conformant cluster without modification.
How It Works

One gateway.
Total visibility.

Every tool call passes through a single intelligent proxy. Nothing bypasses it. Nothing is invisible to it.

1

Agent makes a tool call

Any MCP client — Claude Desktop, Cursor, your custom agent — sends a JSON-RPC tool call to the Synapse Relay gateway endpoint. The agent's configuration never changes. Only the URL changes.

2

Gateway intercepts and inspects

The Go gateway receives the call in microseconds. It extracts the tenant ID, the tool name, the client identity, and the full argument payload before deciding what to do with any of it.

3

Rate limiting check

Redis validates whether this tenant and this tool are within their configured sliding-window limits. If exceeded, the call is rejected immediately with a Retry-After header. No upstream call is made.

4

Policy evaluation

Open Policy Agent evaluates the call against your Rego rules in under a millisecond. The result is allow, deny, or requires_approval. Every decision is recorded with its full context.

5

PII redaction on input

The argument payload is sent to Microsoft Presidio. Every detected entity — emails, phone numbers, SSNs, financial data — is replaced with a typed placeholder token before the payload is ever logged. The original data continues to the tool. Only the redacted version is stored.

6

Approval gate (if destructive)

If the policy marks the call as requiring approval, it is held. The dashboard shows the redacted payload to an authorized reviewer. The agent receives a pending status. The tool receives nothing until a human makes a decision.

7

Forward to upstream MCP server

Allowed calls are forwarded to the actual MCP server — the auto-generated container running your API integration. The tool runs. The result comes back through the gateway.

8

PII redaction on output, then log

The response is also passed through Presidio. The redacted version is stored in PostgreSQL. OpenTelemetry traces are exported. Prometheus metrics are incremented. The live dashboard receives the event via WebSocket. The agent receives the original response.

Why Synapse Relay

Honestly better than
every alternative.

Not because they are bad products. Because they were not built for this problem.

Capability Synapse Relay API Gateways (Kong/Apigee) Cloud AI Observability Build Your Own
MCP-native protocol support ✓ Native ✗ ⚬ Partial ⚬ You build it
Zero per-token cost ✓ Self-hosted vLLM ✓ N/A ✗ Charged per event ⚬ Depends
Data never leaves your cloud ✓ 100% ✓ Self-hosted only ✗ Data sent to vendor ✓ If done correctly
PII detection & redaction ✓ Presidio + regex ✗ ⚬ Some vendors ⚬ Months of work
Human-in-the-loop approvals ✓ Built-in gate ✗ ✗ ⚬ Build + integrate
Open Policy Agent integration ✓ Deep integration ⚬ Plugin only ✗ ⚬ You wire it up
MCP server auto-generation ✓ From OpenAPI/PG/GitHub ✗ ✗ ✗
Connector hub (Composio/Zapier) ✓ One-click import ✗ ✗ ✗
Real-time live dashboard ✓ WebSocket feed ⚬ Third-party needed ✓ Managed ⚬ Build it yourself
Time to production ✓ 1 command ⚬ Days to weeks ⚬ Hours (with tradeoffs) ✗ 6–12 months
Enterprise compliance (HIPAA/SOC2) ✓ All data on-prem ⚬ Possible, complex ✗ Data leaves boundary ⚬ If architected for it
Open source ✓ Apache 2.0, full platform ⚬ Open core ✗ ✓ It's yours
Ready?

One command.
Full control.

The agents are already running. The question is whether you can see what they're doing.

See the Full Demo Read the Architecture