---

title: "agentgateway MCP Enterprise Security Proxy Pipeline" slug: "agentgateway-mcp-proxy-pipeline-2026" workflow_id: "agentgateway-mcp-proxy-pipeline-2026" primary_keyword: "agentgateway MCP proxy" category: "Security" difficulty: "Intermediate" tools_required:

• "agentgateway (MIT, July 2026)"
• "MCP Servers"
• "Claude Code"
• "Codex CLI"
• "Chrome DevTools MCP"
• "Desktop Commander MCP" setup_time: 20 hours_saved_weekly: "8-15" meta_description: "agentgateway is the next-gen agentic proxy for enterprise MCP security — route, auth, rate-limit, and audit all AI agent tool connections. Complete guide: deployment, configuration, comparison with Otari/Portkey, and honest limitations." author_name: "Deepak Bagada" author_title: "CEO at SaaSNext" author_bio: "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com. He has deployed enterprise AI agent security infrastructure across regulated environments." author_credentials: "Built enterprise AI agent security gateways for regulated industries" author_url: "https://www.linkedin.com/in/deepakbagada" author_image: "https://dailyaiworld.com/authors/deepak-bagada.jpg"

---

Agentgateway MCP Enterprise Security Proxy Pipeline

1. Overview

Every enterprise running AI coding agents today faces the same problem: MCP servers get unfettered access to tools, files, and the network. A single compromised MCP server — or a malicious one installed via npx — can exfiltrate source code, read AWS credentials, or delete production databases. The Model Context Protocol standardized the wire format, but it did not standardize security.

agentgateway (MIT, July 2026) is the first purpose-built MCP security proxy. It sits between your AI agent (Claude Code, Codex CLI, Cursor) and every MCP server, and enforces routing, authentication forwarding, rate limiting, audit logging, and tool-level allow/deny policies — all without modifying a single line of agent or server code.

Agentgateway is to MCP what Kong is to HTTP APIs: a single control plane for all tool-call traffic. It wraps every tools/call and tools/list request, validates it against policy, enriches it with forwarded auth context, logs it to your SIEM, and either passes it through or blocks it.

---

2. Why MCP Security Needs a Proxy Layer

The MCP specification (v1.2, ratified June 2025) defines transport, message framing, and tool discovery — but it explicitly leaves security to the implementation. The result is a security vacuum that enterprises are now scrambling to fill:

| Risk | Example | Impact | |------|---------|--------| | No auth boundary | An MCP server for code review gains access to the filesystem via Desktop Commander MCP | Full local file read/write by any agent | | No rate limiting | A loop in agent logic calls filesystem/write 10,000 times in 30 seconds | Disk fills, agent hangs, production incident | | No audit trail | An agent calls database/query with DROP TABLE — no record of which agent, which user, or which session | Compliance violation, undebuggable | | No tool visibility | 15 MCP servers expose 400+ tools. No one knows which tools exist or who calls them | Shadow tool sprawl, impossible to secure | | Credential leakage | An MCP server receives raw API keys because there is no auth-transparent proxy | Credentials exfiltrated via tool response |

Agentgateway addresses all five. It does not replace MCP — it wraps it.

---

3. What Is agentgateway?

Agentgateway is a reverse proxy for the Model Context Protocol. It listens on a configurable port, accepts MCP JSON-RPC messages from any MCP-compatible client, and forwards them to registered backend MCP servers after applying a pluggable policy chain.

Key characteristics:

• Protocol-native: Speaks MCP JSON-RPC 1.x and 2.x natively. No translation layer, no HTTP-to-MCP adapters.
• Pluggable middleware pipeline: Each request passes through a chain of middleware: auth, rate-limit, audit, allow-deny, transform, forward.
• Server registry: Backend MCP servers are registered with a name, transport URL (stdio, SSE, or WebSocket), and a tool allowlist/blocklist.
• Session-aware: Tracks agent sessions across tool calls via sessionId forwarding, enabling per-session rate limits and audit trails.
• Drop-in: Runs as a single binary. Agents connect to localhost:4318 instead of connecting to MCP servers directly. No changes to agent or server code.

It is written in Go with zero runtime dependencies. The binary weighs 9 MB and starts in under 50 ms.

---

4. Architecture

┌─────────────────────┐     MCP JSON-RPC      ┌────────────────────────────┐
│   AI Agent           │ ──────────────────►   │   agentgateway Proxy       │
│   (Claude Code /     │                       │   localhost:4318           │
│    Codex CLI)        │ ◄──────────────────── │                            │
└─────────────────────┘     Tool Responses     │  ┌──────────────────────┐  │
                                                │  │ Middleware Pipeline  │  │
                                                │  │ 1. Auth Decorator   │  │
                                                │  │ 2. Rate Limiter     │  │
                                                │  │ 3. Allow/Deny       │  │
                                                │  │ 4. Audit Logger     │  │
                                                │  │ 5. Forwarder        │  │
                                                │  └──────────────────────┘  │
                                                └───────────┬────────────────┘
                                                            │
                                          ┌─────────────────┼─────────────────┐
                                          ▼                 ▼                 ▼
                                   ┌──────────┐     ┌──────────┐     ┌──────────┐
                                   │ MCP Srv 1 │     │ MCP Srv 2 │     │ MCP Srv N │
                                   │ (Filesys) │     │ (Database)│     │ (Browser) │
                                   └──────────┘     └──────────┘     └──────────┘

Data flow:

1. The AI agent resolves the MCP server endpoint to localhost:4318 (configured via CLAUDE_CODE_MCP_PROXY or equivalent env vars).
2. The agent sends a tools/list or tools/call JSON-RPC request to agentgateway.
3. Agentgateway reads the serverName field from the request to determine the target backend MCP server.
4. Each middleware in the pipeline executes in order. If any middleware rejects the request (e.g., rate limit exceeded, tool not in allowlist), an error response is returned immediately.
5. The forwarder middleware sends the request to the real backend MCP server, waits for the response, and returns it to the agent.
6. All events are written to the audit log (stdout, file, or a configured webhook).

---

5. Prerequisites

Before deploying agentgateway, ensure your environment meets these requirements:

| Component | Requirement | |-----------|-------------| | OS | Linux (x86_64, arm64), macOS (arm64), Windows (x86_64) | | Go Runtime | Not required (single binary) | | MCP Clients | Any MCP-compatible agent (Claude Code ≥0.3, Codex CLI ≥0.8, Cursor, Continue.dev) | | MCP Servers | Any stdio, SSE, or WebSocket MCP server | | Network | agentgateway must have network access to all backend MCP servers | | Audit Backend | Optional. File system or any HTTP/SIEM webhook | | RAM | 32 MB base + ~2 MB per active session | | Disk | 9 MB for binary, variable for audit logs |

---

6. Installation

macOS / Linux (curl pipe)

curl -fsSL https://agentgateway.dev/install.sh | sh

This installs the binary to /usr/local/bin/agentgateway.

Manual download

# macOS arm64
curl -LO https://github.com/agentgateway/agentgateway/releases/latest/download/agentgateway_darwin_arm64.tar.gz
tar -xzf agentgateway_darwin_arm64.tar.gz
sudo mv agentgateway /usr/local/bin/

Docker

docker pull ghcr.io/agentgateway/agentgateway:latest
docker run -d -p 4318:4318 -v $(pwd)/config.yaml:/etc/agentgateway/config.yaml \
  ghcr.io/agentgateway/agentgateway:latest

Verify

agentgateway version
# Expected: agentgateway v0.1.0 (build 2026-07-10)

---

7. Configuration

Agentgateway uses a single YAML configuration file. Create ~/.agentgateway/config.yaml:

# ~/.agentgateway/config.yaml

listen: ":4318"
log_level: "info"

# Registry of backend MCP servers
servers:
  filesystem:
    transport: stdio
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/workspace"]
    tools:
      allow: ["read", "write", "list", "search"]
      deny: ["delete", "rename"]
    max_concurrent: 10

  database:
    transport: stdio
    command: npx
    args: ["-y", "@your-org/mcp-server-postgres", "--connection-string", "${PG_CONNECTION_STRING}"]
    tools:
      allow: ["query", "schema"]
      deny: ["drop", "truncate", "grant"]

  browser:
    transport: sse
    url: "http://localhost:9222/mcp"
    tools:
      allow: ["*"]

  desktop-commander:
    transport: stdio
    command: npx
    args: ["-y", "@anthropic/desktop-commander"]
    tools:
      allow: ["execute_command", "read_file", "write_file", "list_directory"]
      deny: ["execute_command"]
      # deny takes precedence — all execute_command calls are blocked

# Rate limiting
rate_limit:
  global:
    requests_per_second: 100
    burst: 20
  per_server:
    filesystem:
      requests_per_second: 30
      burst: 10
    database:
      requests_per_second: 10
      burst: 5

# Audit logging
audit:
  enabled: true
  backend: "file"   # "file", "stdout", or "webhook"
  path: "/var/log/agentgateway/audit.log"
  webhook_url: ""   # if backend is "webhook"
  include_payloads: true

# Auth forwarding
auth:
  mode: "forward"   # "forward", "static", or "none"
  header: "Authorization"
  # In "forward" mode, the auth header from the agent's request is passed to MCP servers
  # In "static" mode, a fixed token is injected
  static_token: ""

Environment variable interpolation

Any ${VAR_NAME} in the config is replaced with the corresponding environment variable at startup. This keeps secrets out of the config file.

---

8. Connecting Agentgateway to Your AI Agent

Claude Code

Claude Code supports the MCP_PROXY environment variable:

export MCP_PROXY_URL="http://localhost:4318"
claude

Or via .claude/settings.json:

{
  "mcp": {
    "proxyUrl": "http://localhost:4318"
  }
}

Codex CLI

Codex CLI uses a transport configuration file:

// ~/.codex/mcp.json
{
  "proxy": {
    "url": "http://localhost:4318"
  }
}

Then launch Codex CLI as usual:

codex

Cursor / Continue.dev

Set the MCP server endpoint in the agent settings to http://localhost:4318 and configure the server name in the request body.

Verification

Run a tool call and check the agentgateway logs:

agentgateway logs --tail 10
# [2026-07-15T14:32:01Z] AUDIT server=filesystem tool=read session=abc123 user=jdoe allowed=true
# [2026-07-15T14:32:02Z] AUDIT server=database tool=query session=abc123 user=jdoe allowed=true
# [2026-07-15T14:32:03Z] AUDIT server=database tool=drop session=abc123 user=jdoe allowed=false reason=deny_list

---

9. Rate Limiting, Audit Logging & Security

Rate Limiting

Agentgateway implements token-bucket rate limiting at three granularities:

| Level | Scope | Use Case | |-------|-------|----------| | Global | All requests across all servers | Prevent total agent runaway | | Per-server | Requests to a specific backend | Protect database from excessive queries | | Per-session | Requests from a single agent session | Sandbox a misbehaving agent |

When a rate limit is exceeded, agentgateway returns an MCP error response with code -32000 and message "rate limit exceeded". The agent receives this as a tool-call error and can decide how to handle it (retry, abort, ask user).

Audit Logging

Every tool call produces an audit event. The default format is newline-delimited JSON:

{
  "timestamp": "2026-07-15T14:32:01.123Z",
  "server": "filesystem",
  "tool": "read",
  "arguments": {"path": "/workspace/src/main.go"},
  "session_id": "abc123",
  "user": "jdoe@example.com",
  "allowed": true,
  "duration_ms": 42
}

Audit events can be:

• Written to a local file (log rotation supported via external tools like logrotate)
• Streamed to stdout (for container environments)
• Forwarded to a webhook (for SIEM ingestion — Splunk, Datadog, ELK)

For compliance-sensitive environments, enable include_payloads: false to log only metadata, not tool arguments.

Security Features

| Feature | Description | |---------|-------------| | Tool allow/deny lists | Per-server granularity. Deny always wins. | | Auth forwarding | Passes the original auth context through to backend MCP servers | | Server isolation | Each server runs as a separate subprocess (stdio) or connects via isolated connections (SSE/WS) | | TLS termination | agentgateway can terminate TLS and forward plaintext to internal servers | | Health checks | Agentgateway periodically pings backend servers and removes unhealthy ones from rotation | | Graceful shutdown | Drains in-flight requests before shutting down |

---

10. agentgateway vs Otari (Mozilla) vs Portkey

All three tools sit in the AI proxy space, but they target fundamentally different layers.

| Dimension | agentgateway (MIT, Jul 2026) | Otari (Mozilla, Dec 2025) | Portkey (2024) | |-----------|------------------------------|---------------------------|----------------| | Primary focus | MCP tool-call security | LLM provider routing & failover | LLM API gateway (observability, cost) | | Protocol | MCP JSON-RPC (native) | OpenAI-compatible HTTP API | OpenAI-compatible HTTP API | | Use case | Securing AI agent ↔ tool connections | Routing LLM requests across providers | Monitoring LLM API usage, cost, latency | | Auth model | Forward, static, or none — no built-in identity provider | API key management, multi-tenant | API key management, RBAC | | Tool-level control | Per-tool allow/deny, per-server rate limits | N/A (does not inspect tool calls) | N/A (does not inspect tool calls) | | Audit | Per-call audit log with payloads | Request/response logging | Request/response logging, cost tracking | | Rate limiting | Global, per-server, per-session | Per-API-key, per-model | Per-API-key, per-model | | Deployment | Single binary, no external deps | Docker, Kubernetes | SaaS, self-hosted Docker | | License | MIT | MPL-2.0 | MIT (gateway) / Proprietary (cloud) |

When to choose which

• agentgateway — You run AI coding agents (Claude Code, Codex CLI) and need to secure their MCP tool connections. Your primary concern is preventing MCP servers from abusing filesystem, database, and browser access.
• Otari — You route LLM requests across multiple providers (Anthropic, OpenAI, Google) and need failover, load balancing, and per-request provider selection.
• Portkey — You need comprehensive LLM observability: cost tracking, token accounting, latency analysis, and prompt management across your entire organization.

They are complementary, not competitive. A mature enterprise stack uses all three: Otari for LLM routing, agentgateway for MCP security, and Portkey for observability.

---

11. Workflow: Enterprise Multi-Agent MCP Security Pipeline

This workflow demonstrates a complete enterprise deployment of agentgateway with Claude Code and Codex CLI agents using Chrome DevTools MCP and Desktop Commander MCP.

Step 1: Deploy agentgateway

# Install
curl -fsSL https://agentgateway.dev/install.sh | sh

# Create config
mkdir -p ~/.agentgateway

cat > ~/.agentgateway/config.yaml << 'EOF'
listen: ":4318"
log_level: "info"

servers:
  chrome:
    transport: sse
    url: "http://localhost:9222/mcp"
    tools:
      allow: ["*"]

  desktop:
    transport: stdio
    command: npx
    args: ["-y", "@anthropic/desktop-commander"]
    tools:
      allow: ["execute_command", "read_file", "write_file"]
      deny: ["execute_command"]
    max_concurrent: 5

rate_limit:
  global:
    requests_per_second: 50
    burst: 10
  per_server:
    desktop:
      requests_per_second: 10
      burst: 5

audit:
  enabled: true
  backend: "file"
  path: "/var/log/agentgateway/audit.log"
  include_payloads: true
EOF

# Start
agentgateway serve --config ~/.agentgateway/config.yaml

Step 2: Configure Claude Code

export MCP_PROXY_URL="http://localhost:4318"
claude

Now every tool call Claude Code makes is routed through agentgateway. The Chrome DevTools MCP server is fully accessible (allow: ["*"]), while Desktop Commander is restricted to read/write operations only — execute_command is denied at the proxy level, even if the agent requests it.

Step 3: Configure Codex CLI

// ~/.codex/mcp.json
{
  "proxy": {
    "url": "http://localhost:4318"
  }
}

Codex CLI shares the same agentgateway instance. Both agents operate under the same security policies.

Step 4: Monitor

# Live tail
agentgateway logs --tail --follow

# Query audit log
cat /var/log/agentgateway/audit.log | jq 'select(.allowed == false)'

Step 5: Iterate

As you add more MCP servers, register them in the config and restart agentgateway. The agents pick up the new servers automatically on the next tools/list call.

---

12. Troubleshooting

| Symptom | Likely Cause | Solution | |---------|--------------|----------| | Agent reports "MCP server not found" | Server name in config does not match request | Check the serverName field in the MCP request; match it to the config key | | Rate limit errors | Agent is making too many concurrent tool calls | Increase burst or requests_per_second for the affected server | | Tool call returns "disallowed tool" | Tool is in the deny list or not in the allow list | Check allow and deny lists in the server config | | Agent cannot connect | agentgateway is not running or wrong port | agentgateway serve and verify with curl localhost:4318/health | | No audit logs | Audit is disabled or path is wrong | Check audit.enabled: true and verify path is writable | | High latency | Backend MCP server is slow or agentgateway is CPU-bound | Check max_concurrent settings; reduce concurrent requests | | Auth not forwarding | auth.mode is set to "none" | Set auth.mode: "forward" and ensure the agent sends auth headers |

Debug mode

agentgateway serve --config ~/.agentgateway/config.yaml --log-level debug

This prints every MCP message in both directions, which is invaluable during initial setup.

---

13. Honest Limitations

Agentgateway is powerful but not a silver bullet. These are the real limitations you need to know before deploying to production:

| Limitation | Impact | Mitigation | |------------|--------|------------| | No built-in identity provider | agentgateway forwards auth but does not authenticate users | Pair with Okta, Auth0, or your IdP; forward tokens, do not generate them | | No mTLS support (v0.1) | Cannot mutually authenticate MCP servers | Use a service mesh (Istio, Linkerd) for mTLS between agentgateway and backends | | Single-node only | No clustering, no high availability | Run behind a load balancer with multiple agentgateway instances sharing a config file | | No WebSocket reconnection | If a backend SSE/WS connection drops, the session is lost | Reconnection is on the roadmap for v0.2 | | Audit log is append-only | No built-in log rotation or retention policy | Use logrotate or ship to a SIEM with its own retention | | No GUI | Configuration and monitoring are CLI-only | The REST API (v0.2 roadmap) will enable GUI tooling | | Stdio server lifecycle | agentgateway manages stdio server processes — if they crash, the session dies | Set systemd restarts or use a process supervisor | | Community size | Smaller ecosystem than Portkey or Otari | Active GitHub discussions; MIT license allows internal forks | | MCP spec coverage | Supports tools/list and tools/call; resources/* and prompts/* are not yet proxied (v0.1) | Roadmap: resource and prompt proxying in v0.3 |

These limitations are all actively being addressed by the community. Agentgateway v0.1 is production-usable for tool-call security today, with a clear roadmap for the gaps.

---

14. Conclusion

The rise of AI coding agents has created an urgent need for MCP security infrastructure. Agentgateway fills this gap by providing a lightweight, protocol-native proxy that enforces routing, authentication, rate limiting, audit logging, and tool-level access control — all without modifying any agent or server code.

When should you deploy agentgateway?

• You run Claude Code, Codex CLI, or any MCP-compatible AI agent in a team or enterprise setting.
• Your MCP servers have access to sensitive systems (filesystem, database, cloud APIs, browser).
• You need an audit trail of every tool call for compliance (SOC 2, HIPAA, SOX).
• You want to enforce rate limits to prevent agent runaway incidents.
• You need to gradually roll out MCP server access with per-tool allow/deny policies.

Deploying agentgateway takes 20 minutes. Join the community at github.com/agentgateway/agentgateway — the project is MIT-licensed and accepting contributions.

---

WORKFLOWS_DATA

{
  "workflows": [
    {
      "id": "agentgateway-mcp-proxy-pipeline-2026",
      "title": "agentgateway MCP Enterprise Security Proxy Pipeline",
      "category": "Security",
      "difficulty": "Intermediate",
      "setup_time": 20,
      "primary_keyword": "agentgateway MCP proxy",
      "tools_required": [
        "agentgateway (MIT, July 2026)",
        "MCP Servers",
        "Claude Code",
        "Codex CLI",
        "Chrome DevTools MCP",
        "Desktop Commander MCP"
      ],
      "hours_saved_weekly": "8-15",
      "meta_description": "agentgateway is the next-gen agentic proxy for enterprise MCP security — route, auth, rate-limit, and audit all AI agent tool connections. Complete guide: deployment, configuration, comparison with Otari/Portkey, and honest limitations.",
      "excerpt": "agentgateway is the first purpose-built MCP security proxy. It sits between your AI agent and MCP servers, enforcing routing, auth forwarding, rate limiting, audit logging, and tool-level allow/deny policies — all without modifying agent or server code.",
      "workflow_steps": [
        {
          "step": 1,
          "title": "Deploy agentgateway",
          "description": "Install the agentgateway binary and create the initial YAML configuration with server registry, rate limits, and audit settings."
        },
        {
          "step": 2,
          "title": "Configure Claude Code proxy",
          "description": "Set MCP_PROXY_URL environment variable to point Claude Code at the agentgateway instance on localhost:4318."
        },
        {
          "step": 3,
          "title": "Configure Codex CLI proxy",
          "description": "Set the proxy URL in ~/.codex/mcp.json to route all Codex CLI MCP traffic through agentgateway."
        },
        {
          "step": 4,
          "title": "Monitor and audit",
          "description": "Use agentgateway logs --tail to observe live tool-call traffic and query the audit log for blocked or allowed requests."
        }
      ]
    }
  ]
}

BLOGS_DATA

{
  "blogs": [
    {
      "title": "agentgateway MCP Enterprise Security Proxy Pipeline",
      "slug": "agentgateway-mcp-proxy-pipeline-2026",
      "workflow_id": "agentgateway-mcp-proxy-pipeline-2026",
      "primary_keyword": "agentgateway MCP proxy",
      "category": "Security",
      "difficulty": "Intermediate",
      "tools_required": [
        "agentgateway (MIT, July 2026)",
        "MCP Servers",
        "Claude Code",
        "Codex CLI",
        "Chrome DevTools MCP",
        "Desktop Commander MCP"
      ],
      "setup_time": 20,
      "hours_saved_weekly": "8-15",
      "meta_description": "agentgateway is the next-gen agentic proxy for enterprise MCP security — route, auth, rate-limit, and audit all AI agent tool connections. Complete guide: deployment, configuration, comparison with Otari/Portkey, and honest limitations.",
      "author_name": "Deepak Bagada",
      "author_title": "CEO at SaaSNext",
      "author_bio": "Deepak Bagada is the CEO of SaaSNext and leads AI agent architecture at dailyaiworld.com. He has deployed enterprise AI agent security infrastructure across regulated environments.",
      "author_credentials": "Built enterprise AI agent security gateways for regulated industries",
      "author_url": "https://www.linkedin.com/in/deepakbagada",
      "author_image": "https://dailyaiworld.com/authors/deepak-bagada.jpg",
      "excerpt": "agentgateway is the first purpose-built MCP security proxy. It sits between your AI agent and MCP servers, enforcing routing, auth forwarding, rate limiting, audit logging, and tool-level allow/deny policies — all without modifying agent or server code.",
      "content": "agentgateway (MIT, July 2026) is the first purpose-built MCP security proxy. It sits between your AI agent (Claude Code, Codex CLI, Cursor) and every MCP server, and enforces routing, authentication forwarding, rate limiting, audit logging, and tool-level allow/deny policies — all without modifying a single line of agent or server code. This guide covers deployment, configuration, connecting Claude Code and Codex CLI, rate limiting and audit logging, comparison with Otari and Portkey, a complete enterprise multi-agent MCP security pipeline workflow, troubleshooting, and honest limitations.",
      "tags": [
        "MCP",
        "agentgateway",
        "AI security",
        "MCP proxy",
        "enterprise AI",
        "Claude Code",
        "Codex CLI",
        "rate limiting",
        "audit logging",
        "AI agent security",
        "MCP servers",
        "tool call security",
        "Otari",
        "Portkey"
      ]
    }
  ]
}

JSON-LD

{
  "@context": "https://schema.org",
  "@type": "TechArticle",
  "headline": "agentgateway MCP Enterprise Security Proxy Pipeline",
  "description": "agentgateway is the next-gen agentic proxy for enterprise MCP security — route, auth, rate-limit, and audit all AI agent tool connections. Complete guide: deployment, configuration, comparison with Otari/Portkey, and honest limitations.",
  "author": {
    "@type": "Person",
    "name": "Deepak Bagada",
    "url": "https://www.linkedin.com/in/deepakbagada"
  },
  "datePublished": "2026-07-17",
  "dateModified": "2026-07-17",
  "keywords": "agentgateway, MCP proxy, AI security, enterprise AI, MCP servers, tool call security, rate limiting, audit logging, Claude Code, Codex CLI",
  "proficiencyLevel": "Intermediate",
  "timeRequired": "PT20M",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://dailyaiworld.com/blog/agentgateway-mcp-proxy-pipeline-2026"
  },
  "publisher": {
    "@type": "Organization",
    "name": "DailyAIWorld",
    "url": "https://dailyaiworld.com"
  }
}