Home/ Products/ Bud MCP Foundry/ Product Brief
Bud MCP Foundry overview
Product Brief · Layer 05 · Integration & Tools

Bud MCP Foundry

The unified control plane that automatically produces, federates, and governs MCP tools at enterprise scale — turning the systems you already own into governed, agent-ready capabilities, and federating 1,000+ third-party MCPs, without rebuilding anything.

Product reference v1.0 July 2026 ~14 min read
Read the whitepaper
01At a glance

The unified control plane for enterprise MCP.

Organizations that spent years building their systems shouldn't have to rebuild for the agentic future. MCP Foundry produces the MCP capabilities your enterprise needs from your internal APIs, documentation, knowledge, and systems — and governs every agent–tool interaction through one plane.

MCPs federated1,000+
Gateway latency<50ms
LLM context10× smaller
Uptime SLA target99.9%
gateway-boundary & per-query measures · methodology in §06
What it is
Turns the tools, workflows, and knowledge you already own into governed MCP tools — drop in an OpenAPI spec, a Postman collection, a PDF, or a live REST endpoint
What took weeks of custom engineering takes minutes, zero code — with confidence scoring and evaluator gating before anything goes live
Federates 1,000+ third-party MCPs and auto-bridges stdio-only tools into one four-tier catalog
Any MCP-compliant agent can do real work with your organisation — identity, policy, cost, and audit enforced on every single call
What it is not
✕A simple gateway or proxy — it produces, evaluates, and versions MCPs, not just routes them
✕An agent framework — agents from Claude to LangChain to Bud Agent consume it, one layer up
✕A model-serving plane — inference is Bud AI Foundry, one layer below; MCP Foundry runs on CPUs, no GPUs required
02Where it fits

Layer 05 of the Bud stack.

Every agent above it reaches your enterprise through this layer; every layer below gives it inference and hardware. It is the integration waist of the stack.

08Bud Agentruns the workflowaugment 07Bud Studiobuilds & shares the agentconsume 06Bud SENTRYguardrails + auditgovern 05Bud MCP Foundryproduce · federate · govern MCP toolsintegrate 04Bud AI Foundryinference + serving + FinOpsserve 03Bud Model Foundrytraining + ARTtrain 02Bud Podyour own compute cloudcompute 01Bud LayerZerokernel orchestrationhardware

Consumed by Studio, Agent, and SENTRY — plus any external MCP-compliant agent: Claude, ChatGPT, Gemini, Cursor, LangChain, CrewAI, AutoGen.

Builds on Bud AI Foundry for on-prem SLM inference — Smart Discovery makes SLM-driven tool use feasible on your own hardware.

03Capabilities, in full

Produce. Compose. Federate. Govern.

Six capability groups — the four pillars plus the two engines underneath them, expanded to the specifics an evaluator needs.

01Produce — auto-generate MCP toolsOpenAPI specs, Postman collections, PDFs, vendor docs, live REST endpoints, GUI recordings & RPA bots in — governed MCP tools out · no API? the pipeline crawls documentation sites, even JS-rendered ones behind complex auth · production-grade by default — confidence scoring, dry-run preview & Evaluator gating on every tool before it enters the registryminutes, zero code
02Compose — four-tier tool managementFederate 1,000+ remote MCPs — Slack, Notion, GitHub, Atlassian, Composio, Zapier — governed instantly · auto-bridge stdio-only tools — Drive, Gmail, Postgres ship as local CLIs, exposed to any agent at scale · AI-generate MCPs that don't exist for internal & legacy systems · register your own skills, prompts, resources & A2A agents in the same catalogindustry-first
03Federate — hybrid multi-zone architectureOne catalog, many zones — each compliance zone, region, or business unit runs its own Foundry instance with its own audit trail; agents see a single capability surface · capabilities federate; data never leaves its zone — auditors see clean separation, operations teams see clean isolation · no GPUs required — classical CPU infrastructure; GPU-hosted intelligence stays in a separate zonezero leakage
04Govern — enterprise governance planeSSO with the IdP you already run — Google, Entra ID, Okta, Keycloak, GitHub — on day one · three-scope RBAC, multi-tenant team isolation & policy hooks at every lifecycle stage — scope access down to a single tool · zero plaintext credentials anywhere · immutable, tamper-evident audit logs answer "who did what, with whose permission, at what cost" on every invocationevery call
05Bud MCP Gateway — every protocol in, one surface outHTTP/JSON-RPC, Server-Sent Events, WebSocket, Streamable HTTP (2025-06-18) & stdio normalized into one dispatch layer · unified dispatch via Bifrost — all four tool tiers routed transparently through a single catalog, agents never see the seams · virtual server composition — bundle tools, resources, prompts & A2A agents into curated endpoints per team5 protocols
06Bud Smart Discovery — per-query tool retrievalDon't dump 1,000 tools into the model's context — semantic retrieval sends only the three it needs, per query · ~5K tokens per query instead of ~50K · tool-selection accuracy rises from ~62% to ~94% · makes SLMs feasible for tool-using agents on-prem · 200K+ tools per catalog without context blowout10× · +32 pts

Skills Registry. Compose tools, resources, and prompts into self-contained, versioned Skills with one-click rollback — distributed through a governed catalog and portable across Claude, ChatGPT, Cursor, LangChain, CrewAI, or on-prem SLMs. Your procedural expertise travels with you, not locked to any single vendor.

04How it works

Architecture & components.

An MCPfication pipeline, a seven-layer request path, and defense-in-depth security — wired so every agent–tool interaction carries identity, policy, cost, and audit context automatically.

The MCPfication pipeline — nine stages, automated

01IngestOpenAPI, Postman, PDF, REST
02CrawlDoc sites, JS-rendered, auth
03EnhanceAI-powered tool enrichment
04EvaluateConfidence scores, dry-run
05RegisterFour-tier unified registry
06GovernAuth, RBAC, policy hooks
07ComposeVirtual servers, Skills
08ServeGateway dispatch, 5 protocols
09ObserveLogFire, OTel, Prometheus

For the operator it is three steps: drop in your source, review what's generated, approve and ship — live with auth, rate limits, and observability already wired in.

Seven layers of clean separation

Every request traverses the full middleware stack before reaching a backend service — consistent security, observability, and policy behavior regardless of which component is accessed.

LayerNameWhat lives there
01ConsumerAI agents and assistants (Claude, ChatGPT, Gemini, Cursor), frameworks (LangChain, CrewAI, AutoGen, LangGraph), web dashboard, REST/CLI/SDK clients, federated peer Foundries.
02TransportFive protocols normalized into one API surface: HTTP/JSON-RPC, SSE, WebSocket, Streamable HTTP (2025-06-18), stdio (auto-bridged).
03API GatewaySingle entry point on a high-performance ASGI framework with ORJSON serialization; validates, routes, serves OpenAPI, exposes /health, /ready, /health/security.
04Middleware stackOrdered pipeline: CORS, compression, security headers, protocol validation, token scoping, authentication, RBAC, request logging, observability instrumentation.
05Backend servicesSix services in concert: Federation, Gateway, Tool, Team Management, A2A, and MCP Server — each with defined responsibility and telemetry.
06MCP RegistryFour-tier unified registry: remote hosted, self-hosted stdio-bridged, AI-generated, and internally managed — with virtual server composition on top.
07Data & observabilityRedis cache and session state; PostgreSQL 14+ (or MySQL 8+ / MariaDB 10.6+) with SQLAlchemy 2.0 and Alembic; LogFire, OpenTelemetry, Prometheus instrumentation.

Observability — agent-level trails for every interaction

Agent behavior is non-deterministic. When something goes wrong the question is never just "what call failed" — but what the agent was trying to do, with what context, and what sequence of calls led there.

LogFire

Per-agent activity trails across tool invocations, skill executions, prompt renderings, and A2A communications — built for post-incident analysis and compliance reporting.

OpenTelemetry

W3C Trace Context propagation; export to OTLP (gRPC/HTTP), Jaeger, Zipkin, or console. Traces persist in-platform when external infrastructure is unavailable.

Prometheus

Counts, duration and size histograms on every endpoint; per-tool, per-gateway, per-server, per-agent, per-skill, per-prompt counters via /metrics/prometheus.

Health & HA

/health, /ready, /health/security; auto-healing with separated enabled/reachable status; active-active multi-region, PostgreSQL streaming replication, Redis Sentinel/Cluster.

Security — four containment perimeters, no plaintext at the core

01NetworkTLS / HTTPSHSTSWSSCSPCORSOutbound TLS
02ApplicationJWT · 9 algorithmsArgon2idOAuth 2.0 SSO3-scope RBACPKCE / S256
03DataAES-256-GCMFernetSHA-256Argon2id hashes
04OperationalStartup security validationAudit logSBOMImage signing

At the core: no plaintext credentials. Anywhere. Enforced at the schema level — the platform refuses to boot on weak defaults. Authentication is on by default on every API, protocol, and admin endpoint; admin surfaces are disabled unless explicitly enabled.

05Deployment & compatibility

Runs on what your ops team already knows.

Classical CPU infrastructure, standard databases, active-active HA — deployed per zone, region, or business unit, with capabilities federated across every boundary.

RequirementDetail
ComputeCPU-only — no GPUs required. GPU-hosted intelligence (model serving) stays in a separate zone via Bud AI Foundry.
DatabasePostgreSQL 14+ · MySQL 8+ · MariaDB 10.6+ — SQLAlchemy 2.0, Alembic migrations, streaming replication.
Cache & sessionsRedis, with Sentinel/Cluster for high availability.
High availabilityActive-active multi-region; auto-healing with separated enabled/reachable status; 99.9% uptime SLA target.
Data residencyPer-zone instances (PCI, EU region, customer data, business units) with their own audit trails — data never leaves its zone; capabilities federate. In sovereign and air-gapped environments the third-party catalog runs as a self-hosted set.
ComplianceControls map to SOC 2 Trust Services Criteria, ISO 27001:2022 Annex A, OWASP Top 10 (2021), NIST CSF 2.0. SOC 2 Type II certification in progress. RBAC, SSO, residency, immutable audit trails, and exportable compliance reports ship at deployment.

Pre-built enterprise

Microsoft 365AWSAzureVMware vCenterEntra IDMS Graph

Exchange, SharePoint, Teams, OneDrive · S3, Lambda, DynamoDB, CloudWatch, IAM, EC2, RDS · Azure Storage, Functions, Cosmos DB, Monitor · VM lifecycle & snapshots.

Third-party & stdio MCPs

SlackNotionGitHubAtlassianComposio 850+Zapier 8,000+

Plus Databricks Marketplace (LSEG, FactSet, Nasdaq, Moody's, S&P) — and auto-bridged stdio tools: Drive, Gmail, Calendar, Sheets, Filesystem, PostgreSQL, Redis, SQLite, MySQL, Playwright.

LLMs & agent frameworks

OpenAIClaudeGeminiMistralLangChainCrewAIAutoGen / AG2A2A · ACP

Vendor-agnostic: any OpenAI-compatible endpoint, on-premises SLMs via Bud AI Foundry, Bud Agent native, custom framework plugins.

06Proof & methodology

Every headline number, with its basis.

The numbers your platform team needs to know before they sign off — each paired with how it was measured, not asserted in isolation.

<50ms
Gateway latency
How it's measuredRequest latency at the gateway boundary — validation, routing, and middleware, isolated from backend tool time. Related floors: <500ms end-to-end for simple tools, <100ms first-byte on streaming responses.
10×
Smaller LLM context
How it's measuredTokens per query on the same catalog: ~50,000 with naive full-catalog wiring versus ~5,000 with per-query semantic retrieval. Cost reduction is directly proportional to context size.
+32pts
Tool-selection accuracy
How it's measuredCorrect-tool selection rate on identical queries and catalog: ~62% with the full catalog in context versus ~94% with Smart Discovery's top-k retrieval — fewer wrong-tool invocations, and SLM-feasible where a frontier LLM was previously required.
100K/min
Throughput per node
How it's measuredRequest capacity per node with 10K+ concurrent connections at minimum spec — on CPU-only infrastructure. Availability: 99.9% uptime SLA target under continuous monitoring with auto-healing.
ClaimMetricBaseline / boundaryConditions
<50ms gatewayrequest latencyGateway boundary onlybackend time excluded
<500ms tool executionend-to-endSimple toolsfull middleware stack
<100ms streamingtime-to-first-byteStreaming responsesSSE / Streamable HTTP
10K+ concurrencyopen connectionsSingle nodeminimum spec
10× context reductiontokens / queryNaive full-catalog wiringsame catalog & queries
99.9% availabilityuptime SLA targetContinuous monitoringactive-active multi-region
07Why Bud Optional

Against the obvious alternative.

The closest comparable is IBM ContextForge. Both are enterprise MCP gateways — only one produces, evaluates, and versions MCPs end-to-end.

Where both deliver

  • JSON-RPC, HTTP, SSE, WebSocket, Streamable HTTP protocol support
  • Gateway federation with DNS-SD auto-discovery
  • Tool registry with JSON Schema validation and rate limiting
  • External MCP server connectivity
  • Plugin extension system with pre/post hooks

Where only Bud has full coverage

  • Automated MCP creation from API documentation
  • Firecrawl-powered documentation crawling
  • AI-powered tool enhancement and evaluation
  • Multi-format ingestion: OpenAPI, Postman, PDF, HTML, Markdown
  • Confidence scoring, dry-run preview, bulk conflict resolution
  • Predefined Skills Registry with one-click deployment
  • Snapshot-based skill versioning
  • Bifrost unified routing plane
  • Auto-bridge stdio MCPs to HTTP/SSE with horizontal scaling
  • LogFire AI-agent activity logging
  • Token scoping (IP / time / server), startup security validation
Automated MCPfication Four-tier registry Federated hybrid zones Smart Discovery Zero plaintext credentials Portable Skills registry
08Who it's for Optional

Worked example: how a bank uses it.

KYC files, Finacle core, AML engines, SWIFT, credit bureaus — MCPified into audience-scoped servers, routed through governed agents to four distinct user groups.

For customers

Self-serve banking answers

General-info and interest-rate-calculator MCPs exposed to commercial assistants like OpenAI and Claude — scoped so customer agents can only reach customer tools.

For employees

AML investigation in one query

"Investigate AML alert #4471" — Smart Discovery retrieves exactly aml.lookup_alert, crm.customer_360, and tx.recent_history from thousands of tools, via the internal agent.

For management

Compliance & risk on demand

Compliance-dashboard and risk-reporting MCPs built from policy manuals and RBI filings — served to leadership through the same governed plane.

For partners

A governed partner surface

Partner-API and settlement-&-reconciliation MCPs consumed by trusted third-party agents — with their own scopes, rate limits, and audit trail.

Platform teams

One catalog, every zone

PCI zone, EU region, customer-data zone, trading BU — each with its own Foundry instance and audit trail, while agents see a single capability surface.

Security & compliance

Forensics on every call

Immutable, tamper-evident logs across every tier answer "who did what, with whose permission, at what cost" — exportable for auditors, mapped to SOC 2 and ISO 27001.

09Go deeper & next steps

The authoritative narrative, in full.

This brief is the reference. For the argument, figures, and print-grade detail, read the whitepaper — or watch the platform run from ingestion to federation to observability.

Whitepaper

Technical whitepaper

The Universal MCPfication Platform

For enterprise AI transformation

A deep dive into the architecture, generation pipeline, federation gateway, and governance model behind Bud MCP Foundry.

Read the whitepaper
Product page

Back to overview

Bud MCP Foundry

Produce, federate, and govern MCP tools

Return to the high-level product page — the headline numbers and the interactive overview of the four pillars.

Back to the product page
Get started with Bud

Put your data on it.

The fastest way to see what an integrated AI operating system does for your enterprise is a proof-of-concept on your infrastructure, with your data.

Request a POC Talk to the team
01 Identify a use case where complexity, cost, or governance is a known pain point.
02 Joint discovery — Bud maps your AI pain points to platform capabilities.
03 POC in days, on your hardware, with your data.