BMW's blueprint for governing hundreds of AI agents at enterprise scale
BMW Group details its five-part architecture for scaling agentic AI, using infrastructure-as-code and graduated trust levels to balance developer speed with strict compliance.
The BMW Group has published a detailed case study on how it governs hundreds of autonomous AI agents across more than 12,500 developers. Released in November 2026, the report outlines an architectural framework designed to maintain safety, security, and cost-efficiency while allowing rapid innovation in a highly regulated automotive environment.
What happened
BMW’s R&D division manages approximately 500 million lines of vehicle software code, supported by a cloud backend of over 1,300 microservices serving 24 million connected vehicles. As the company integrated generative AI into this ecosystem, it faced a common enterprise dilemma: development teams needed the freedom to experiment, but the organization required strict adherence to quality and compliance standards. Without a unified approach, the risk was creating fragmented "AI islands" and duplicating work across globally distributed teams.
To address this, BMW moved away from ad-hoc agent development toward a standardized, industrialized model. The company codified its best practices into reusable infrastructure-as-code (IaC) templates. This shift ensures that governance is not a retroactive audit but a structural component of the agent lifecycle. By treating agent architecture as a shared utility rather than a custom build for every team, BMW aims to scale agentic systems without sacrificing the velocity required for modern software delivery.
How it works
The core of BMW’s solution is the "agent harness," a runtime layer that wraps around large language models (LLMs). This harness handles execution loops, tool dispatch, memory management, and observability. Crucially, it externalizes governance rules such as authentication, rate limiting, and content filtering. By placing these controls at the integration layer—specifically via a Model Context Protocol (MCP) gateway and a central registry—the system remains resilient to changes in underlying frameworks or models. Governance survives team reorganizations because it is enforced by deterministic code in the CI/CD pipeline, not by prompts that an agent might ignore.
BMW organizes its approach around five interlocking practices. First, it implements graduated trust levels for agent actions. Level 0 requires human approval for every step, suitable for high-risk tasks. Level 1 allows autonomous execution with asynchronous human review. Level 2 permits full autonomy within strict, deterministic policy boundaries. Second, the company emphasizes continuous instrumentation and evaluation. Agents are tested against ground-truth datasets before deployment, and their reasoning trajectories are traced using OpenTelemetry. This ensures that quality is measured against real-world scenarios rather than synthetic tests.
Third, BMW advocates for composability through a three-tier hierarchy. Atomic "MCP tools" handle single capabilities like API calls. "Skills" bundle these tools into domain-specific logic, such as code review. "Flows" orchestrate skills into end-to-end business processes. This structure prevents monolithic agents from becoming bloated and inaccurate. Finally, a central registry acts as a discovery and governance checkpoint, preventing duplicate work and enforcing security standards before any asset reaches production.
Key details
- Graduated Autonomy: Trust levels are assigned per step, not per agent, allowing workflows to mix human-in-the-loop and autonomous actions based on risk.
- Deterministic Enforcement: Governance rules run as code in the CI/CD pipeline, ensuring they cannot be overridden by agent prompts or reasoning.
- Three-Tier Composition: Systems are built from atomic MCP tools, composed into Skills, and orchestrated into Flows, enabling independent scaling and testing.
- Central Registry: A mandatory registry catalogs agents, tools, and skills, performing automated deduplication and security checks before approval.
- Ground-Truth Evaluation: Agents must pass evaluation against representative datasets in the pipeline, with verification tests gating non-deterministic evaluations.
- Infrastructure-as-Code: All agent infrastructure, including least-privilege roles and policy rules, is provisioned via Terraform or CloudFormation.
Why it matters
For engineering leaders and architects, this case study provides a concrete pattern for moving beyond proof-of-concept AI projects. Many organizations struggle with the "governance dichotomy," where security teams block innovation or developers bypass safeguards to meet deadlines. BMW’s model demonstrates that governance can be automated and embedded into the developer workflow. By shifting compliance checks to the left—into the build pipeline—teams can innovate quickly while maintaining an audit trail required for regulated industries.
The emphasis on composability also addresses the technical debt often associated with early AI adoption. Monolithic agents that attempt to do everything often suffer from context window limits, higher latency, and increased hallucination rates. By breaking capabilities into small, reusable tools and skills, organizations can improve accuracy and reduce costs. Specialized agents can run on smaller, cheaper models, and updates to one skill do not require redeploying the entire system. This modularity is essential for long-term maintainability.
What you can do
- Implement an agent harness: Decouple governance logic from agent code by using a runtime layer that enforces authentication and rate limiting externally.
- Define trust levels: Categorize agent actions by risk and assign appropriate autonomy levels, starting with human-in-the-loop for new capabilities.
- Adopt a tiered composition model: Break down complex agents into atomic tools, domain-specific skills, and end-to-end flows to improve testability and reuse.
- Establish a central registry: Create a mandatory catalog for all AI assets to prevent duplication and enforce security standards before deployment.
- Instrument for observability: Use OpenTelemetry to trace agent reasoning steps and tool invocations, ensuring you can audit why an agent made a specific decision.
- Codify governance: Translate policy requirements into infrastructure-as-code templates and CI/CD pipeline gates to automate compliance checks.



