convez.ai
MCP ServerSegurançaIntermediário
JaidenSy

Arbiter — Gateway de Segurança para Agentes IA via MCP

JaidenSy/Arbiter

Controle de acesso, secrets vault e auditoria para agentes IA via MCP

Ver no GitHub
InicialPluginScore · de 0 a 100

MCP gateway que intercepta todas as chamadas de ferramentas de agentes IA, implementando controle de acesso em nível de ferramenta, gestão de secrets criptografados, cache semântico e auditoria completa. Cada agente recebe identidade criptográfica independente em vez de compartilhar credenciais, eliminando riscos de vazamento e oferecendo compliance.

Instalação

$npx convez-ai JaidenSy/Arbiter

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 1 mês
Versão
—
Issues abertas
24
Contribuidores
1

Casos de uso

  • Enforcing tool-level RBAC para agentes IA em produção
  • Auditoria e compliance de chamadas de agentes (SOC 2, HIPAA)
  • Centralizar e criptografar secrets injetados em tempo de execução

Veredito

Arbiter resolve um problema real em deployment de agentes: controle fino de acesso e auditoria sem sacrificar flexibilidade. Implementação robusta com FastAPI, PostgreSQL e criptografia AES-256-GCM; suporta self-hosted e SaaS, com free tier acessível.

README

A tradução para o português deste README ainda está na fila.

Arbiter

The MCP security gateway for AI agents.

License FastAPI React PostgreSQL Deployed on Railway

arbiterai.dev → · API Docs → · support@arbiterai.dev


Claude Code calling tools through Arbiter: a permitted call succeeds (semantic-cache hit), a denied tool is blocked by per-agent RBAC, and both land in the audit trail

Real session, left to right: Claude Code calls ask_question through the gateway (cache hit, 10 ms), then attempts read_wiki_contents — blocked by tool-level RBAC with a clean error, and every call lands in the session trace.


The problem

Most teams give every AI agent the same credentials and let it call any tool it wants. Secrets are copy-pasted into .env files or hardcoded in prompts. There's no audit trail and no access control.

When something goes wrong — a runaway agent, a leaked key, a compliance audit — you have nothing.

What Arbiter does

Arbiter is an MCP gateway that sits between your AI agents and your MCP servers. Every tool call flows through it:

  • Agent identity — each agent gets a cryptographic API key (nxai_...). No shared credentials.
  • Tool-level RBAC — grant only the tools each agent needs. read_file ≠ delete_file.
  • Encrypted vault — secrets stored with AES-256-GCM, injected at proxy time. Agents never see raw keys.
  • Semantic cache — similar tool calls return cached responses via pgvector ANN search. Cuts latency and cost.
  • Full audit log — every request and response captured with duration, cache status, and agent identity.
  • Rate limiting — per-agent, per-tool limits enforced at the gateway.

Arbiter dashboard


Get started

Hosted (free tier, no credit card)

  1. Sign up at arbiterai.dev.
  2. Register an agent → get your nxai_... key.
  3. Point your MCP client at the gateway — done:
{
  "mcpServers": {
    "arbiter": {
      "type": "http",
      "url": "https://api.arbiterai.dev/mcp",
      "headers": { "Authorization": "Bearer nxai_..." }
    }
  }
}

Works with Claude Code, Claude Desktop, Cursor, VS Code — anything that speaks MCP. All your registered MCP servers appear as one connection, tools namespaced as server__tool. Every tool is advertised; RBAC is enforced at call time, so a denied call returns a spec-compliant isError result and lands in the audit log. See docs/mcp-endpoint.md.

Self-hosted

git clone https://github.com/JaidenSy/Arbiter.git && cd Arbiter
cp .env.example .env   # set JWT_SECRET_KEY and VAULT_ENCRYPTION_KEY at minimum
docker compose up -d
# API on :8000  ·  frontend on :5173

Generate a vault key: python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"

Full env var reference in .env.example.


How it works

1 — Register an agent

curl -X POST https://api.arbiterai.dev/api/v1/agents \
  -H "Authorization: Bearer <your-jwt>" \
  -d '{"name": "my-claude-agent"}'

# → { "api_key": "nxai_abc123..." }   ← shown once, store it

2 — Grant tool permissions

curl -X POST https://api.arbiterai.dev/api/v1/agents/<agent-id>/permissions \
  -H "Authorization: Bearer <your-jwt>" \
  -d '{"mcp_server_id": "<server-id>", "tool_name": "read_file"}'

3 — Proxy a tool call

Through any MCP client (see config above), or directly via the REST API:

curl -X POST https://api.arbiterai.dev/api/v1/proxy/tool-call \
  -H "Authorization: Bearer nxai_abc123..." \
  -d '{
    "server_name": "filesystem",
    "tool_name": "read_file",
    "params": { "path": "/app/config.json" }
  }'

# → { "result": {...}, "cached": false, "agent_id": "agt_xyz789" }

If the agent calls a tool it wasn't granted, it gets a 403. Not a silent pass-through.

4 — Store secrets in the vault

Store once, reference everywhere — secrets are injected at proxy time, never written to plaintext config.

Dashboard → Vault → Add Secret:

Name: github_pat   Value: ghp_xxxx...

Reference in your MCP server's auth headers:

Authorization: {{vault:github_pat}}

Arbiter resolves {{vault:github_pat}} at call time. The raw token never touches the database.


Architecture

Your AI Agent
      │  Bearer nxai_...
      ▼
┌─────────────────────────────────────┐
│           Arbiter Gateway           │
│                                     │
│  ┌─────────┐  ┌───────┐  ┌───────┐ │
│  │  RBAC   │  │ Vault │  │ Cache │ │
│  └────┬────┘  └───┬───┘  └───┬───┘ │
│       └───────────┴───────────┘     │
│                   │                 │
│              ┌────▼────┐            │
│              │  Proxy  │            │
│              └────┬────┘            │
└───────────────────┼─────────────────┘
                    │
          ┌─────────┴──────────┐
          ▼                    ▼
   MCP Server A          MCP Server B
  (GitHub, Slack…)     (Filesystem…)

Comparison

ArbiterLiteLLMPortkeyRoll your own
Per-agent identity✅❌❌weeks
Tool-level RBAC✅❌❌weeks
Encrypted secrets vault✅❌❌weeks
Semantic cache (pgvector)✅PartialPartialmonths
Full request/response audit log✅Partial✅weeks
MCP-native (not LLM proxy)✅❌❌—
Self-hostable✅✅❌✅
CostFree–$29/moFree/OSS$49+/moeng time

Plans

FreePro ($29/mo)Enterprise
Agents225Unlimited
MCP Servers350Unlimited
Tool calls/mo5,000100,000Unlimited
Secrets10100Unlimited
Semantic cache✗✓✓
Self-hosted support✗✗✓

Organizations & multi-tenancy

Every account creates one organization. All resources (agents, MCP servers, vault secrets, quota) are org-scoped — fully isolated from other orgs.

RoleCapabilities
ownerFull control: billing, members, all resources
adminCreate/delete agents, MCP servers, vault secrets
memberRead-only dashboard

Contributing

PRs are welcome. For significant changes, open an issue first to discuss scope.

git clone https://github.com/JaidenSy/Arbiter.git && cd Arbiter

# backend
cd backend && python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env && alembic upgrade head
uvicorn app.main:app --reload --port 8000

# frontend (separate terminal)
cd frontend && pnpm install
cp .env.example .env.local && pnpm dev

# tests
cd backend && pytest

Stack

LayerTechnology
APIFastAPI 0.115, Python 3.12
DatabasePostgreSQL 16 + pgvector
CacheRedis 7
Embeddingssentence-transformers (all-MiniLM-L6-v2)
FrontendReact 18, TypeScript, Vite, Tailwind CSS
AuthJWT HS256 (60 min) + refresh tokens, Google/GitHub OAuth2
BillingStripe
DeployRailway (API + DB + Redis) · Vercel (frontend)

Security

Responsible disclosure: security@arbiterai.dev


License

Arbiter uses an open-core model:

  • Core gateway — Apache 2.0 — free, permissive, self-hostable. No copyleft obligations. Use it in closed-source products, build SaaS on it, embed it anywhere.
  • Enterprise modules (SSO, SCIM, KMS) — Commercial License — a commercial license is required only to use the enterprise modules. Contact jaidensy07@gmail.com.

© 2026 Jaiden Sy.

Ver o original no GitHub

Bom para

Relacionados