Introducing SmartGate

We're launching SmartGate — an MCP-native gateway that compresses, deduplicates, and hard-caps agent tool traffic before runaway loops show up on your invoice.

Why we built it

Agent frameworks don't warn you when a loop is burning tokens. They just bill. SmartGate sits in the tool layer — not the LLM layer — so you keep your existing model provider and add guardrails where traffic actually multiplies.

What's included on day one

• Seven MCP tools — fetch, search, compress, dedup, budget, memory, and pipelines
• Full MCP on Free — 2M tokens/month to get started
• Dashboard — Connect, Playground, Activity Logs, Usage Reports, and Budget

Get started

1. Create a free account
2. Follow the Quick Start guide
3. Paste Connect config into Cursor or your MCP host

Questions? support@smartgate.network

Category, not feature dump

SmartGate is the intelligence layer between AI and the world. Brand language leads with five capabilities—Research, Context, Memory, Control, Pipeline—powered by seven algorithm primitives. MCP Gateway is the technical entrance; Intelligence Layer is the category. That distinction keeps us from being miscategorized as another assistant, search engine, LLM proxy, or model router.

Human interface and agent interface

Humans get Web and app experiences (Smart Research, Smart Decision, Smart Knowledge, Smart Intelligence) without needing to understand MCP JSON on marketing pages. Builders get MCP/API on one Streamable HTTP endpoint with Bearer auth so they do not rebuild research infrastructure for every agent. Both interfaces share the same runtime, team isolation, and audit rows.

What ships in the first experience

• Connect — copy host-specific MCP JSON from the Dashboard; do not hand-type stale blog examples.
• Playground — REST evaluation path; not a substitute for MCP Connect when validating Cursor.
• Activity Logs / Usage Reports — tool-level evidence and gateway counterfactual savings metrics.
• Plans — Free for evaluation with strict fair-use RPM; Pro, Teams, and Enterprise scale pools, retention, and governance. See /pricing for current fees and Gainshare rules.

Guardrails we publish on purpose

We do not invent customer logos or fixed savings percentages. Compression savings depend on input structure and ratio settings. Free/Playground bursts may receive HTTP 429 by design. Est. USD saved is not your host LLM invoice. Concurrent capacity figures are not marketing claims on this site.

Competitive framing (short)

Get oriented after signup

1. Mint an API key; store it in a secret manager.
2. Paste Connect JSON; restart the host; confirm tools/list.
3. Run one bounded tool call; confirm an Activity Log row.
4. Only then enable long research pipes or shared team keys.

Docs SSOT: Overview, Connect, MCP Endpoint, Security. Support: support@smartgate.network.

The series-wide operator playbook, pre-ship checklist, product links, and closing note live in one place so no post repeats them — jump to What Is an MCP Gateway?.

The seven primitives and what they return

SmartGate registers seven smart_* tools, and the canonical titles live in backend/smartgate/api/mcp_tool_docs.py (TOOL_TITLES). These are the names a host shows on tools/list:

• smart_fetch — Fetch URL as Markdown
• smart_search — Web search
• smart_context_gate — Compress context
• smart_dedup — Semantic deduplication
• smart_budget_guard — Budget check/count/record
• smart_memory — Team memory
• smart_pipe — Pipeline orchestrator

Five of them are annotated read-only: the READ_ONLY_TOOLS set in the same file covers smart_fetch, smart_search, smart_context_gate, smart_dedup, and smart_budget_guard. smart_memory and smart_pipe are the two write-capable primitives, which is why their annotations carry readOnlyHint: false.

Every tool returns a JSON string that the host must parse before use (backend/smartgate/api/mcp_instructions.py, "Output contract"). The defaults are visible in the tool signatures in backend/smartgate/api/mcp.py: smart_context_gate targets a compression ratio of 0.5 (LLMLingua) unless you pass another ratio, smart_dedup uses a similarity threshold of 0.9, and smart_budget_guard's count action defaults to the deepseek-chat model for token estimation.

One endpoint, one auth scheme

There is a single MCP surface, not a family of per-tool URLs. The server is defined in backend/smartgate/api/mcp.py as a FastMCP instance with stateless_http=True, json_response=True, and streamable_http_path="/", mounted at POST /mcp and speaking the MCP 2025-03-26 protocol. In production that resolves to the Streamable HTTP value Connect renders for your deployment (https://smartgate.network/api/mcp).

Two consequences follow. First, because the transport is stateless, there is no session to keep alive between calls and nothing to re-establish after a host restart — the host simply posts JSON-RPC to one path. Second, authentication is configured once at the host level: the key travels as an Authorization: Bearer header, and tenant scope is derived from that key. The server instructions are explicit that callers should not paste keys into tool arguments or pass a foreign team_id (backend/smartgate/api/mcp_instructions.py).

What the audit headers capture

The audit contract is documented in AGENTS.md under "Audit header contract (REST + MCP)". Optional headers on REST calls are read into audit_logs.params:

When the correlation header is absent, the pipeline falls back to the per-request request_id. MCP calls need no client headers for routing: with no headers present the middleware stamps route=mcp (AGENTS.md), and backend/smartgate/api/mcp.py rebinds route="mcp" around each in-stream tool call. That is also why the agent_platform label is worth sending — it is how a Cursor session, an OpenClaw run, and a Hermes run stay distinguishable in Activity Logs.

That is the product surface: seven primitives, one endpoint, one auth scheme, and one shared audit vocabulary.