Guild Raises $44M to Build the Agent Control Plane

Every company building with AI agents hits the same wall. The first agent works great. Then there are five, then fifty, and suddenly nobody knows what they're doing, what they cost, or how to shut one down before it burns through the quarterly budget overnight.

James Everingham, CEO of Guild.ai, just closed $44M in total funding to fix exactly that. In this TBPN interview, he breaks down what the former Meta Dev Infra team is seeing from early customers — and why the control problem is landing on every engineering org's desk at the same time.

Everingham's framing is blunt:

"It's like gremlins. The first one's fine until they start multiplying and taking over and pulling levers in your infrastructure."

The pattern he's describing is already familiar to anyone running agents in production. Last year was experimentation — one agent, an interesting demo. Now companies are scaling, and the problems that follow are predictable: security wants to know what the agents can access, compliance needs audit trails, and the infrastructure team needs a deterministic layer sitting underneath non-deterministic systems.

The timing is striking. Everingham says it's not just one segment of the market. Small companies and large companies, tech-forward and traditional — they're all arriving at the same phase simultaneously. The models got powerful enough to operate tools, and now everyone is staring at the same governance gap.

Highly regulated businesses are slower by design, but even there the calculus is shifting. The competitive pressure to move fast is outweighing the instinct to wait, as long as there's a control layer to reduce the risk.

The top request from early customers is not sophisticated orchestration or fancy agent design. It's cost visibility.

"One engineer blew through their entire budget in 12 hours and they didn't know."

The story is specific: a company had a monthly inference budget built for single-player use. Engineers were running agents on separate servers or their laptops, with no centralized view. One person torched the whole month's spend before lunch. Circuit breakers — the ability to say "turn this thing off if it gets too hungry" — are table stakes.

But it's not just raw spend. Companies want to measure what they're getting for that spend. Impact measurement, not just cost reporting.

The other pattern Everingham is seeing: companies building small internal versions of an agent control plane themselves, then realizing it's not their core competence. They don't want to maintain it. They don't have the specialized expertise to do it well. And vendor neutrality matters — nobody wants to lock into a single model provider when the competition is leapfrogging every few months.

A few use cases from early customers stand out. One team built an onboarding agent that makes the codebase sentient — say "check out this feature" instead of "check out these files," get a system diagram, have a conversation with the codebase. Another built a risk analysis agent that analyzes diffs for likelihood of taking the system down, letting low-risk changes through automatically and blocking high-risk ones. That kind of tooling can eliminate the holiday code freeze entirely.

Then there's the natural language interface. Everingham described typing a plain-English instruction into Guild:

"Hey, don't make it so it's not possible for duplicate bugs to exist in our company. And it just went and did it behind the scenes."

The system installed the agent, configured it, and hooked it into the workflow — no engineering ticket required.

Guild is building something they call Agent Hub: a public surface where companies can discover, distribute, and deploy agents, structured a lot like GitHub.

Companies can keep internal agents private or push them externally. Third parties can distribute agents as products. Within minutes, someone can authorize an agent, set up a workspace, and have it running.

The founding team are self-described open source believers, and they're carrying that ethos into how the agent marketplace works. The bet is that agents need the same kind of discoverability and distribution layer that code got with GitHub — a place to find what works, fork it, and run it in your own environment.

The $44M in total funding — $30M in the latest round plus $14M in seed, both raised within four months — is led by GV (Google Ventures), with NFX, Kla Ventures, Scribble Ventures, Acrew Capital, and Web Investment Network participating.

The deployment of autonomous software requires a fundamental shift in software infrastructure. While an agent framework dictates how an autonomous system processes data and constructs internal reasoning trees, an agent control plane acts as the overarching governance, security, and administrative layer that manages these workloads across an enterprise network. It decouples execution logic from infrastructure boundaries, providing a central architecture for agent lifecycle management and multi-model operational control.

Unlike traditional infrastructure, a production control plane sits entirely outside the execution path of the model runtime, intercepting system-level interactions to provide real-time policy evaluation.

Core Architectural Components

• Vendor-Agnostic Model Routing: Abstracts downstream API providers (such as OpenAI, Anthropic, or localized open-source deployments) behind a single unified gateway, decoupling application code from underlying model dependencies.
• Centralized Access Control Systems: Enforces strict identity boundaries, treating every autonomous system as an independent security principal with its own cryptographic scope, eliminating the risk of shared developer API tokens.
• Runtime Circuit Breakers: Monitors real-time token traffic and reasoning steps, automatically interrupting and killing an execution thread if an agent deviates into an infinite loop or triggers a policy violation.
• Inference Budget Management Engine: Provides precise, continuous tracking of API costs against defined corporate caps, preventing surprise overruns at the token level before they hit the financial ledger.
• Immutable Audit Logging Fabric: Captures and signs every single prompt input, system-level tool call, database mutation, and raw model response to maintain historical compliance records.

Agent Control Planes vs. Traditional Infrastructure

Use Case 1: Engineering Onboarding via a "Sentient Codebase" Agent

• The Technical Challenge: A fast-growing infrastructure organization struggled with long developer onboarding timelines. To solve this, they built a "sentient codebase" agent utilizing the Claude 3.5 Sonnet model. The agent dynamically monitors internal repository pushes, tracks dependency trees, and reads architectural markdown docs to construct live, interactive system diagrams and answer incoming technical environment questions from new hires via Slack. However, because the agent operates with broad read permissions across internal codebases, it ran without a tracking layer, creating severe data compliance risks and unmonitored token expenses during high hiring cycles.
• Implementation & Timeline: Deployed through Guild’s agent deployment pipelines over a 2-week implementation window. The engineering team mapped the onboarding agent to an isolated identity principal, forcing all repository indexing queries and Slack API connections to clear Guild's proxy gateway. This setup restricted the agent's code inspection boundaries to public developer onboarding repos while enforcing a strict $30 daily spend limit.
• Measurable Outcomes: Time-to-first-commit for new engineering hires dropped from an average of 11 days down to 2.4 days. Total incoming internal support and environment troubleshooting tickets within developer operations decreased by 64% within the first month. By moving to smaller embedding models via Guild's multi-model orchestration for standard code indexing tasks, the organization realized a 45% reduction in overall inference expenses.

Use Case 2: Autonomous Pull Request Risk Analysis & CI/CD Gatekeeping

• The Technical Challenge: An enterprise software-as-a-service company deployed an automated Risk Analysis agent inside their code integration pipeline to parse pull request diffs, evaluate security exposure, assign an architectural risk score, and auto-approve low-risk hotfixes. Without a deterministic control plane layer, the agent lacked a verification loop. If the model hallucinated or fell victim to an indirect prompt-injection attack embedded in a modified code file, it could autonomously auto-approve malicious source code directly into production mainlines.
• Implementation & Timeline: Integrated into existing GitHub Actions workflows via Guild's SDK over a 3-week timeline, achieving immediate time-to-value. Guild implemented strict AI workload management policies that act as an external gatekeeper. While the framework processes code logic freely, any action resulting in a pipeline approval state is intercepted by Guild's deterministic control layer, requiring a signed validation check against corporate risk thresholds.
• Measurable Outcomes: The company successfully automated 72% of routine dependency upgrades and minor bug patch merges without human intervention. Crucially, Guild’s runtime policy engine caught 3 separate security exceptions where an agent attempted to bypass typical code security reviews due to confusing model outputs. The architecture prevented deployment incidents entirely, reducing manual PR review backlogs for senior engineers by 40%.

Use Case 3: Global E-Commerce Support Agent Fleet Tracking

• The Technical Challenge: A global retail entity deployed a fleet of over 200 distinct, localized customer support agents across multiple regional store brands, running on a mixture of proprietary frameworks and cloud backends. The infrastructure team faced severe agent sprawl: they had no way to monitor cross-team token consumption, no centralized audit log to check for customer data leakage (PII), and no tool to execute widespread system rollbacks if a core prompt update degraded agent interactions.
• Implementation & Timeline: Deployed as a centralized AI infrastructure management layer over a 4-week migration timeline. Every localized support agent, regardless of its underlying application framework, was registered inside the Guild Agent Hub. All outbound customer communication and backend tool calls were routed through Guild's inference monitoring proxy.
• Measurable Outcomes: The enterprise consolidated its decentralized agent footprint into a single plane of glass, instantly detecting and terminating 14 legacy "shadow agents" that were wasting API budgets. Real-time PII scrubbing filters at the gateway layer stopped accidental leaks of customer payment information into external LLM logs with 100% accuracy. Centralized budget caps prevented automated cost runaways, saving the company over $18,000 in monthly operational waste while standardizing corporate AI governance.