Servers everywhere, inventory nowhere
Every team runs its own MCP servers with credentials pasted into local config files. Nobody can list what is deployed, let alone what it can do.
Appwire sits between your AI clients and your MCP servers. Every tool call is authenticated, authorized, approved, and audited, behind a single URL your whole organization can use.
Drop-in for the clients and servers you already use
The problem
Model Context Protocol made it trivial to hand agents real tools. It also made it trivial to lose track of who can call what, with which credentials, and what happened next.
Every team runs its own MCP servers with credentials pasted into local config files. Nobody can list what is deployed, let alone what it can do.
Tools execute as whatever token happened to be in the client, not as the person or agent behind the request. Least privilege is impossible.
When an agent updates the wrong record, the only log lives on a laptop. Try explaining that to your auditor, or your customer.
The platform
Appwire is an MCP server to your clients and an MCP client to your servers. That position lets it enforce identity, policy, and audit on every request without changing either side.
Roles sync from Okta, Microsoft Entra ID, Google Workspace, or any OIDC provider. Allow, deny, or require approval per server, per tool, or per argument pattern. One policy, enforced everywhere.
policy: platform-eng-default
subjects: { groups: [platform-eng] }
rules:
- allow: github.* where: { repo: "acme/*" }
- require_approval: jira.create_issue
- deny: "*.delete_*"
Every call is logged with the principal, tool, argument hash, latency, cost, and the parent LLM trace. Export logs, traces, and metrics over OpenTelemetry to Datadog, Grafana, Splunk, or BigQuery.
Scope access per user, team, environment, or customer. Attach rate limits and budgets to each key. Rotate without touching a single client config.
Appwire holds the credentials, not your laptops. OAuth 2.0 at the server or per-user level with automatic refresh, backed by Vault, AWS, GCP, or Azure secret stores.
Mark tools read-only, auto-approved, or approval-required. Approvers get the full request in Slack, Teams, or email. Nothing runs until someone says so.
Bundle tools from many upstream servers into one curated server. Clients see one URL and only the tools they are allowed to use.
Scan arguments and results for secrets, PII, and prompt injection. Redact or block before anything reaches the model or the server.
Load schemas on demand instead of shipping hundreds of tool definitions in every prompt. Smaller context, faster runs, lower bills.
How it works
Select any stage to see exactly what Appwire does before, during, and after a tool executes.
Control plane
Inventory every server and tool, approve or deny requests, trace every call back to the person and agent behind it, and attribute cost to the team that owns it.
| Time | Tool | Principal | Server | Latency | Status | Cost |
|---|---|---|---|---|---|---|
| 14:02:31 | github.create_pull_request | jane@acme.com | github | 231 ms | allowed | $0.0004 |
| 14:02:29 | slack.post_message | agent:release-bot | slack | 96 ms | allowed | $0.0002 |
| 14:02:26 | jira.create_issue | sam@acme.com | jira | — | approval | — |
| 14:02:22 | postgres.query | agent:analytics | postgres | 188 ms | allowed | $0.0011 |
| 14:02:19 | postgres.drop_table | contractor@vendor.io | postgres | 2 ms | blocked | $0 |
| 14:02:15 | salesforce.update_opportunity | priya@acme.com | salesforce | 342 ms | allowed | $0.0008 |
| 14:02:11 | notion.search | lee@acme.com | notion | 121 ms | allowed | $0.0003 |
Quick start
Run the gateway, register a server, point a client. Add SSO, policy, and approvals when you are ready. No changes to your MCP servers, no SDK to adopt.
# Run locally
$ npx appwire@latest
# ...or with Docker
$ docker run -p 8080:8080 ghcr.io/appwire/gateway:latest
# ...or on Kubernetes
$ helm install appwire oci://ghcr.io/appwire/charts/appwire
✓ gateway listening on http://localhost:8080/mcp
✓ console at http://localhost:8080# Register an upstream MCP server
$ appwire servers add github \
--transport http \
--url https://api.githubcopilot.com/mcp/ \
--auth oauth2 --oauth-profile github-enterprise
# Local STDIO servers work too
$ appwire servers add postgres \
--transport stdio \
--command "npx -y @modelcontextprotocol/server-postgres" \
--secret DATABASE_URL=vault://db/analytics/readonly
✓ github 18 tools discovered
✓ postgres 6 tools discovered{
"mcpServers": {
"acme": {
"url": "https://mcp.acme.appwire.io/mcp",
"headers": {
"Authorization": "Bearer aw_vk_platform_eng_••••"
}
}
}
}
// One URL. Every server and tool this key is allowed to see.
// Works the same in Cursor, Claude Code, VS Code, or your own SDK.policy: platform-eng-default
subjects:
groups: [platform-eng] # synced from Okta
rules:
- allow: github.*
where: { repo: "acme/*" }
- require_approval: jira.create_issue
approvers: [eng-managers]
channel: slack:#eng-approvals
- deny: "*.delete_*"
limits:
rate: 600/min
budget: $50/day
guardrails: [pii-redact, secret-scan, prompt-injection]Deployment and compliance
Appwire runs where your data lives, with no outbound dependencies. Credentials never leave your environment, and every action produces audit-ready evidence.
Helm chart and Terraform modules for AWS, GCP, and Azure. Horizontal scaling with cluster mode, using Postgres or your managed database as state.
A single binary with offline licensing and zero call-home. Bring your own identity provider, secret store, and observability stack.
Fully managed, single-tenant deployments with regional data residency. Same binary, same policies, none of the operations.
Immutable audit logs, SCIM provisioning, encryption in transit and at rest, and exportable evidence for your SOC 2 Type II, HIPAA, GDPR, and ISO 27001 programs.
Editions
Every plan includes the full gateway, every transport, and unlimited servers. Enterprise adds the governance layer large organizations need.
| Capability | Small to Medium business | Enterprise |
|---|---|---|
| Gateway core, all transports, unlimited servers | ✓ | ✓ |
| Virtual MCP servers and tool groups | ✓ | ✓ |
| OpenTelemetry export | ✓ | ✓ |
| Policy engine and approvals | Basic | ✓ Advanced, argument-level |
| SSO (SAML / OIDC) and SCIM | — | ✓ |
| Secret store integrations (Vault, AWS, GCP, Azure) | — | ✓ |
| Guardrails: PII, secrets, prompt injection | — | ✓ |
| Cluster mode and high availability | — | ✓ |
| Budgets, alerts, and cost attribution | — | ✓ |
| Audit log retention | 7 days | Custom, with legal hold |
| Deployment | Appwire Cloud or self-hosted | VPC, on-prem, air-gapped, or Appwire Cloud |
| Support | Email, next business day | 24×7 with SLA and dedicated engineer |
Pricing
No per-call fees. Pay for the people and teams you govern, not for how much your agents work.
For growing businesses connecting their first AI tools to the systems they already run on.
For engineering orgs rolling out agents with identity and accountability.
For regulated organizations that need Appwire on their own terms.
FAQ
An MCP gateway is a proxy that sits between MCP clients (Claude Desktop, Cursor, your own agents) and MCP servers (GitHub, Slack, your databases). Clients connect to the gateway instead of to each server. The gateway handles authentication, authorization, credential management, and logging for every tool call that passes through it.
No. Appwire speaks standard MCP on both sides. Register your existing servers over STDIO, streamable HTTP, or SSE, then point your clients at one Appwire URL. Existing servers keep working exactly as they do today.
Only when your policy says so. Each tool can be marked auto-approved, approval-required, or denied, and rules can depend on the caller, the arguments, or both. By default, write operations require explicit approval and read operations are allowed.
In your environment. Upstream OAuth tokens and API keys are stored in your secret manager (HashiCorp Vault, AWS Secrets Manager, GCP Secret Manager, Azure Key Vault) or Appwire's encrypted store, and injected at request time. Clients only ever hold a revocable virtual key.
Yes. The gateway has no outbound dependencies and supports offline licensing. Air-gapped deployments are a first-class use case for the Enterprise edition.
An LLM gateway governs calls to models. Appwire governs calls to tools. Most teams run both: Appwire exports the parent LLM trace ID with every tool call so you can join the two in your observability stack.
The free Small to Medium business plan includes the full gateway core, all transports, virtual servers, basic policies, and OpenTelemetry export for up to five users. Team adds SSO, advanced policy, budgets, and 90-day audit retention. Enterprise adds secret store integrations, guardrails, cluster mode, VPC, on-prem, and air-gapped deployment, and custom retention.
Authentication, policy evaluation, and audit logging run in-process and typically add single-digit milliseconds to a tool call. Upstream execution time is unchanged and reported separately so you can see exactly where time is spent.
Get started
Tell us about your environment and we will set up a 14-day Enterprise trial on your infrastructure, or walk you through the gateway in a 30-minute demo.
Prefer email? hello@appwire.io