Guild.ai

Deploy. Govern. Share. The Control Plane for AI Agents.

Agents are moving into production. Production requires control. Guild is the neutral control plane for AI agents, designed to work across all models and vendors. Identity is enforced, and access is controlled. Every action is auditable. Deploy safely. Govern centrally. Share trusted capabilities through the Managed Agent Center and Agent Hub.

At a Glance

• What: The neutral control plane for AI agents — govern, deploy, and share agents across models and vendors.
• For: Engineering teams and enterprises running AI agents in production.
• Key capabilities: Governed runtime, model neutrality, full execution traceability, managed agent lifecycle, enterprise identity (SSO/SCIM/RBAC), Agent Hub.
• Stage: Series A, backed by Google Ventures, NfX, Khosla Ventures, Acrew Capital, Scribble Ventures, and Webb Investment Network.

The Problem

Everyone builds single-player agents. Production demands multiplayer. Most agents today are isolated — confined to one workflow, one person, or team. They lack centralized governance, standardized execution, reuse across organizations, and lifecycle control. Every project reinvents the wheel. When agents start modifying real systems, that fragmentation becomes risk.

The Missing Layer

Most teams are stitching together one-off agents and brittle automations. That works in demos. It fails in production. As agents begin acting on real systems, something has to sit between models and your infrastructure. Guild is that layer.

Every run executes inside a governed runtime that mediates all external tool access, enforces least-privilege permissions, keeps credentials out of agent code, and produces immutable, exportable audit logs.

Agents don't just respond to prompts. They trigger from pull requests, system events, webhooks, and schedules — and become versioned, reusable production systems.

Once governed, they can be shared. Agent Hub makes those capabilities discoverable and reusable across organizations, turning isolated automation into shared infrastructure.

When to Use Guild

Guild is the right layer when agents stop being experiments and start touching real systems. Concretely:

• Moving an agent from prototype to production: The demo works, but nobody can say what the agent accessed or prove it afterwards. Guild puts the run inside a governed runtime — mediated tool calls, least-privilege permissions, credentials out of agent code — and produces the immutable, exportable audit record a security or compliance review will ask for.
• Running multiple models or vendors under one policy: Different teams pick different models, and the cost and access story fragments. Guild applies organization-level model policy, cost controls, and usage visibility across workspaces, agents, and triggers, so vendor choice stays open without giving up central control.
• Reusing an agent across teams instead of rebuilding it: The same reviewer or migration agent gets written three times in three repos. Publish it once as a versioned, permission-scoped artifact — to your organization's catalog, or to Agent Hub for cross-organization reuse — then install, fork, promote, or roll back from there.
• Wiring agents into systems that already exist: Agents that only answer prompts don't fit real workflows. Guild triggers runs from pull requests, webhooks, schedules, API calls, and system events, with typed inputs and outputs and full traces across model and tool calls.
• Extending enterprise identity to autonomous software: Users are governed by SSO and RBAC; agents usually aren't. Guild integrates SSO (SAML/OIDC), SCIM provisioning, and role-based access control, applying the same least-privilege model to agents.

Machine-Readable Resources on This Site

Distinct from the Guild product's own developer documentation above, this marketing site (guild.ai) exposes its own public content and lead-capture flow to agents directly:

• OpenAPI spec: https://www.guild.ai/openapi.json — typed schema for this site's public HTTP endpoints.
• MCP server: https://www.guild.ai/api/mcp — Model Context Protocol, Streamable HTTP transport, unauthenticated. Tools: search_blog, search_pages, get_company_info, request_demo.
• MCP server card: https://www.guild.ai/.well-known/mcp/server-card.json (also served at https://www.guild.ai/.well-known/mcp.json) — the typed tool catalog, discoverable without completing the MCP handshake.
• Markdown rendering: any page listed in this file also serves text/markdown when requested with Accept: text/markdown, or via https://www.guild.ai/api/markdown?path=<pathname>.

The Platform

Guild delivers the infrastructure layer for governed AI agents.

• Governed Runtime: Agents execute inside a secure runtime that mediates every external call, enforces centralized permissions, isolates execution by workspace and organization, and keeps credentials out of agent code, applying policy at the moment of action.
• Model Neutrality: Enterprise AI will not be single-vendor. Bring your own models and vendor agreements while enforcing organization-level model policies, cost controls, and usage visibility across workspaces, agents, and triggers. One platform for any model.
• Full Execution Traceability: Every run produces a complete, immutable record of prompts, tool calls, actions, and outcomes, with exportable logs built for enterprise compliance. If an agent acts, you can see exactly what happened.
• Managed Agent Lifecycle: Agents are published as versioned, permission-scoped artifacts that can be installed, promoted, rolled back, and reused — moving from one-off scripts to governed, shared infrastructure.
• Enterprise Identity Built In: Guild integrates with SSO (SAML/OIDC), SCIM provisioning, and role-based access controls, extending identity and least-privilege enforcement to autonomous software. Not just users.
• Agent Hub: A public, governed surface for publishing, discovering, and reusing trusted agents across organizations. Not just a marketplace, but a shared repository where capabilities compound.

The Product

Built for one builder or a thousand teams.

For Enterprise

Govern agents like production infrastructure. Autonomous software requires the same guardrails as any production system. Guild enforces centralized identity, least-privilege access, and immutable audit logging so enterprise governance extends to AI agents. Control what they can access. See what they did. Prove it. Deploy with confidence. Audit with clarity. Scale without losing control.

• Execution Transparency: Every agent run produces a complete, immutable record — prompts, tool calls, outputs, and outcomes. Built for enterprise compliance, exportable on demand.
• Tracking and Metrics: Track model usage, token spend, and agent activity by workspace, team, or trigger. See what's running, what it costs, and where to optimize.
• Agent Catalog: Browse, install, and manage agents across your organization. Version-controlled, permission-scoped, and ready to deploy — not buried in someone's repo.
• Credentials and Permissions: Keep secrets out of agent code. Guild mediates every external call through centralized credential vaults and least-privilege access policies.

Guild helps enterprises move from AI experimentation to production-grade systems with confidence and control.

For Developers

Build agents like real software. Ship them like products. When agents move from demos to production, reliability becomes the bottleneck. Guild gives developers the primitives they expect: typed interfaces, versioned releases, safe execution boundaries, and full execution traces — so agents behave like systems, not scripts. Define typed inputs and outputs. Run via chat, API, webhooks, or schedules. Inspect full execution traces across model calls and tool actions. Version every change. Attach evals. Promote safely. Roll back confidently.

• Task Initiation: Agents trigger from chat, API calls, webhooks, pull requests, schedules, or system events — not just prompts. Define how your agent starts and what context it receives.
• Code Editor: Write agent logic in a familiar editor with full language support. Define typed inputs and outputs, connect tools, and iterate fast — no YAML wrestling.
• Commit Flows: Every change is versioned. Track what changed, when, and why — with full diff history, rollback support, and promotion across environments.
• Publish Agents: Package and publish agents as versioned, permission-scoped artifacts. Share within your org or publish to Agent Hub for cross-organization reuse.
• Forking and Customization: Fork any agent from the Hub, customize it for your team's needs, and maintain your own version — while still pulling upstream improvements.
• GitHub and Workflow Integration: Connect agents to your existing dev workflows. Trigger from GitHub events, post results to Slack, update Jira — agents that fit where your team already works.

Guild gives developers the runtime foundation to treat agents like real systems — versioned, governed, observable, and safe to scale.

Community

The community turns agents into infrastructure. Agents, integrations, and workflows are published, versioned, permissioned, and continuously improved across organizations in Guild's Agent Hub. Example agents include: AI Code Reviewer, Python Migration, Onboarding Agent, Issue Deduper, Code Quality Analyzer, Oncall Agent, SOC 2 Compliance Agent, Pentest Agent, PII Log Cleaner, Test Case Builder, Documentation Builder, Root Cause Finder, and Prod Deployer.

Glossary

Guild publishes a glossary of key AI agent and infrastructure concepts.

• Agent Control Plane
• AI Agent Governance
• AI Agent Runtime
• AI Agent Observability
• Multi-Agent Systems
• Model Context Protocol (MCP)
• Full glossary

About

Make building with AI as collaborative as open source. The future of software won't be written by one company — it'll be built by all of us. Guild is building tools for intelligent systems, where openness is fundamental to how systems are built, reviewed, and improved collectively.