Building Effective Enterprise Agents - BCG AI Platforms Group Briefing
Navigation rapide
Étiquettes
Partager les diapositives
Building Effective Enterprise Agents - BCG AI Platforms Group Briefing
Vue détaillée de chaque page de diapositive, incluant la mise en page, le contenu clé et les éléments visuels.
Title slide: BCG AI Platforms Group Briefing, November 2025. Authors: Tom Martin, David Heurtaux, Caitlin Barber, and 8 others.
Full-bleed dark background with teal organic shape, BCG AI Platforms Group logo, title and author list
Sets the context: most guidance on AI agents is theoretical or ignores enterprise complexity. This brief aims to address how to build reliable, trusted AI agents in the enterprise with the right patterns, platforms, techniques, and capabilities.
Split layout: text on left with bold key phrases, AI-generated robot image on right looking at legacy infrastructure
Four chapters: (01) Why is it hard to build agents in the enterprise? (02) How do you design an enterprise agent? (03) How do you build an enterprise agent? (04) How do you assemble an agent platform?
Four color-coded cards in a row: green, cyan, yellow, pink
Section divider for Chapter 1.
Dark background with green/teal section marker and title
Three key questions leaders face: How to keep AI value-focused (P&L impact), how to keep AI under control (reliability, security, cost), and how to scale reliably. 75% of technology leaders fear silent failure.
Split layout: leadership questions on left with green cards, MAD AI landscape image and 75% stat on right
Case studies showing agent promise (30-50% time/cost reduction, 30%+ productivity uplift) vs. reality checklist of 15+ implementation challenges. BCG has delivered 300+ agents across clients.
Split layout: left shows case studies and BCG stats, right shows expectation vs reality with long checklist
METR benchmark showing software engineering task complexity handled by LLMs over time (GPT-2 through GPT-5.1-Codex-Max). Constrained agents work now; deep agents are the next frontier.
Split layout: scatter plot chart on left showing LLM progression, future outlook text on right
Limiting factors are not LLMs but legacy systems: (1) Brownfield integrations, (2) Unreliable enterprise data, (3) Lack of evaluations, (4) Governance & audit overhead, (5) OpModel & scale frictions.
Five-column layout with numbered teal headers and detailed descriptions
Five horizons: H0 Constrained agents (at scale), H1 Single agents (adoption rising), H2 Deep agents (adoption rising, focus here), H3 Role-based agents (very early), H4 Agent mesh (early R&D). Reality check badge included.
Horizontal timeline with five horizon cards, maturity badges, and architectural diagrams
BCG adapts the classic Double Diamond for enterprise agents: Diamond 1 (Discover + Define) for design, Diamond 2 (Develop + Deploy) for build. Four phases: Source ideas, Goal decomposition, Build capability, Rollout & iterate.
Two diamond shapes side by side with numbered phases and descriptions below
Section divider for Chapter 2.
Dark background with cyan section marker
2x2 matrix: Goal & Environment complexity vs Risk, Ethics & Governance. Quadrants: Traditional Automation, Agentic Workflows, Human-led with various support levels. Key insight: if clear rules work, avoid building agents for agents sake.
Split layout: 2x2 matrix on left with examples, explanatory text on right
Outcome-first design using Loan Application Processing example. Start with business goals, decompose into dependency trees with pain points, then prioritize agent opportunities. Key mantra: outcomes-not-outputs.
Left side shows decomposition tree example, right side has three key principles
Three levels of agent design: Single agent (single reasoning loop), Deep agent simple (orchestrator + sub-flows), Deep agent complex (multi-agent orchestration with specialized agents).
Three-column comparison showing agent architecture diagrams of increasing complexity
Four human-agent interaction patterns: Agent-assisted (ChatGPT-like), Human-in-the-loop (Claude Code-like), Human-on-the-loop (Crew AI-like), Human-out-of-the-loop (standalone). Each with different trigger and approval mechanisms.
Four-column layout with workflow diagrams and examples for each pattern
Standardized framework for describing and documenting agents. Shows illustrative Loan Agent flow: initial context creation, agent reasoning loop, tool invocation, final response with human approval, and LLMOps tracing.
Detailed agent flow diagram with color-coded components: general, context engineering, AI model, state/memory, tools, errors
ADC structure: Agent-Achievable Goal, Metrics, Inputs/Outputs, Skills/Tools/Capabilities, Fallback behavior, Agent Trigger type (Reactive/Proactive, User-led/System-led). Five principles for effective ADCs.
Split layout: five principles on left, example ADC card on right for Loan Application Processing
From completed ADCs to platform architecture. Key principles: assess current stack first, let design cards drive capability choices, prioritize thin platform MVP, design for production (guardrails, observability), extend selectively.
Split layout: stacked ADC cards and platform architecture diagram on left, five principles on right
Section divider for Chapter 3.
Dark background with yellow section marker
Overview of 14 components: (1) Agent dev lifecycle, (2) Data platform, (3) Memory, (4) Evaluation, (5) Agent orchestration, (6) Prompt tuning, (7) Agent platform build, (8) Context engineering, (9) AI Gateway, (10) Environment design, (11) Low vs pro code, (12) Enterprise LLMOps, (13) Failure modes, (14) Regulatory & compliance.
Grid layout with 14 numbered cards, each with thumbnail image and brief description
Six-phase agent development lifecycle building on ML & SWE lifecycles: (1) Frame the agent, (2) Design agent framework & logic, (3) Prepare evals & environment, (4) Engineer policy & prompts, (5) Test & tune, (6) Launch, monitor & evolve.
Horizontal hexagonal pipeline with six phases, each with detailed bullet points
Four platform types: Standalone agentic solutions (turnkey), Embedded agentic platforms (integrated in enterprise suites), Agent builder platforms (low/no-code), Custom-built agent platforms (full control).
Four-column comparison with illustrations and bullet points
Data platform architecture for agents: retrieval layer (hybrid search, GraphRAG, Text-to-SQL), storage layer (vector DBs, knowledge graphs, OLAP/OLTP), input processing (chunking, embedding, metadata enrichment).
Architecture diagram showing data platform layers with unstructured and structured data sources
Model Gateway architecture: central registry, token/latency monitoring, model routing policies, FinOps cost tracking, and security guardrails. Five key capabilities detailed.
Flow diagram showing tenants through Model Gateway to 3rd party providers, with FinOps and Security boxes
Two deployment models: Environment-level (isolated per environment, faster experimentation) vs Project-level (shared database, central management at scale). LLMOps must deliver prompt management, agent evals, and observability.
Split comparison: two deployment model diagrams side by side with pros/cons
Evaluation framework: agent performance (final outcome, planning & trajectory, single step accuracy) and agent safety & red-teaming (interaction security, agency control, lifecycle integrity). Continuous gather-test-deploy-monitor cycle.
Circular workflow diagram on left, evaluation categories in center, best practices on right
Insurance client case: entity extraction F1 score improved from ~50 to 75 (+25%) over 6 sprints through iterative context engineering (prompts, RAG, tools). Translated to million-dollar top-line impact.
Left side shows entity extraction process, center has F1 score bar chart, right shows sprint progression table
Five integration layers: Smart business layer, Core transaction layer (use MCP), AI layer (design for async), Data layer (use IAM), Infrastructure layer (abstract complexity). Key: treat agents as system actors with clear boundaries.
Hub-and-spoke diagram with agent in center, five surrounding layers with descriptions
Section divider for Chapter 4.
Dark background with pink section marker
Three eras: 2023-24 tightly coupled agents (code+data+deploy in same stack), 2025 decoupled agent platforms (logic separate from backend), 2026+ interoperability across platforms with shared protocols.
Three-column timeline with architectural diagrams showing evolution
Full platform reference architecture: (1) AI Guardrails, (2) LLMOps, (3) MCP & Agent Registry, (4) Model Gateway, (5) No/low-code builders, (6) Agent Framework, (7) Agent Runtime, (8) Memory, (9) Monitoring/Logging/FinOps, (10) Data Platform.
Detailed platform architecture diagram with 10 numbered components and descriptions
Three platform strategies: Unified (single vendor, fast but limited), Hybrid (balanced flexibility with targeted add-ons), Custom/modular (high differentiation, high complexity). Enterprises will converge on hybrid.
Three-column comparison with stacked block diagrams
Three-tier agent ecosystem: Enterprise Orchestration (governance across platforms), Domain Orchestration (operational collaboration between people & agents), Data & Tool Landscape (shared connectors, version/monitor/retire).
Three-tier layered architecture diagram with loan processing example
Decision tree: First evaluate differentiation & complexity (if not differentiating → Buy/Adopt), then execution capability (if limited resources → Buy & Configure/Adapt), if capable → Build/Assemble. Hybrid is inevitable for most enterprises.
Decision tree on left, three options (Adopt/Adapt/Assemble) on right with descriptions
Five gravity factors for platform selection: (1) Data Gravity (strongest force), (2) Systems Gravity (legacy ERP/CRM lock-in), (3) Governance/Security/Compliance, (4) Value & Differentiation, (5) UI/UX complexity. Data access is the strongest pull.
Orbital diagram showing five gravity factors with agent deployments, descriptions on right
Five takeaways: (1) Design for outcomes not outputs, (2) Start simple with eval-driven design, (3) Build on shared enterprise foundations, (4) Choose the right platform based on data/system gravity, (5) Engineer trust, compliance, and resilience by default. Looking ahead: 2026 will be the year agents deliver real value.
Five numbered takeaway cards on left, Looking Ahead text on right
Links to four BCG resources: Tech Foundation for GenAI Success, AI on BCG.com, Latest thinking on Agents, Executive Perspective Series.
Four preview card thumbnails in a 2x2 grid with dark background
18 team member headshots with names: Vladimir Lukic, Nicolas De Bellefonds, Gene Sheenko, Djon Kleine, Tom Martin, Julien Marx, and 12 others.
Three rows of six circular headshot photos with names
Standard BCG legal disclaimer about materials being subject to BCG Standard Terms, not constituting legal/accounting/tax advice, confidentiality, and no fairness opinions.
Split layout: large Disclaimer text on left, full legal text on right
BCG logo closing slide.
Centered BCG logo on dark teal gradient background
Section divider for Technical Appendix with additional deep-dive slides.
Dark background with Technical Appendix title
Five systems: (1) User & Agent Experience (apps, APIs, MCP), (2) Agent Environment (resources, tools), (3) Agent Policy (control flow, context-to-action mapping), (4) Agent Runtime (platforms, scaling), (5) Agent Operations (monitoring, security, lifecycle).
Five horizontal green bars with descriptions and illustrations
Detailed components for each system: Environment (Browser, APIs, Databases, Terminal, MCP servers), Policy (LLMs, Control flow, Threads, Input/Output, Memory), Runtime (API Manager, Hosting, FinOps, Guardrails), Operations (PromptOps, Testing, Evals, Monitoring, SIEM).
Grid table with five system rows and their subcomponents
Seven fundamental challenges: (1) Context sharing & goal alignment, (2) Coordination complexity, (3) Conflict resolution, (4) Long-range planning & memory, (5) Credit assignment, (6) Getting stuck in loops, (7) Task drift. Requires CS breakthroughs, not just better prompting.
Split layout: multi-agent interaction diagram on left, seven numbered challenges on right
Four-level decomposition: Outcome → Strategic Goal → Tactical Goal → Agent-Achievable Goal. eCommerce example: Increase CLV by 25% → Improve retention to 75% → Identify at-risk customers → Agent goals (monitor signals, trigger interventions, send recommendations, suggest products).
Split layout: decomposition hierarchy on left, eCommerce example tree on right
2x2 matrix of agent interaction patterns: Timing (Reactive vs Proactive) x Context Origin (User-led vs System-led). Four quadrants with examples: User Asks & Agent Responds, User Acts & Agent Observes, System Triggers & Agent Responds, System Changes & Agent Observes.
2x2 matrix with LangChain Ambient Agents reference
Four platform types matched to scenarios: Standalone (fast, narrow, one team), Embedded (in-suite agents leveraging native data), Agent Builder (governed low/no-code), Custom-Built (differentiating, bespoke logic). Examples: Adobe Firefly, Salesforce Agentforce, Copilot Studio, open source.
Four-column comparison table with when-to-choose criteria and tech examples
Five strategies: (1) Store context outside the window, (2) Optimize selection & retrieval timing, (3) Compress context over time, (4) Isolate context into separate containers, (5) Actively manage workflow impact. References from Anthropic, LangChain, and Building Manus.
Five-column layout with icons and detailed bullet points, reference articles on right
Memory architecture: STM (temporary context window with Instructions, Knowledge, Tools, Free capacity) and LTM (persistent across sessions: Semantic, Procedural, Episodic). Integration is non-trivial with challenges around promotion, compression, and retrieval.
Two-tier diagram showing STM and LTM with descriptions on right
Seven-step PromptOps cycle: (1) Set up feedback loops, (2) Pin and version prompts, (3) Change one element at a time, (4) Use structured outputs, (5) Evaluate through multiple layers, (6) Complete A/B tests with canary rollouts, (7) Ensure observability with rollback paths.
Circular PromptOps workflow diagram on left, seven numbered best practices on right
Six failure categories: (1) Identity/AuthN/AuthZ failures, (2) Data & content supply chain failures, (3) Orchestration/tools/integration failures, (4) Objective/reasoning/alignment failures, (5) Governance & human failures, (6) Operational/cost/availability failures. Each with examples and mitigations.
Six-column table with failure mode, examples, and mitigations rows
A2A defines how agents talk, coordinate, negotiate, and share state. A2A handles dialogue between agents while MCP enables tool discovery. Leading frameworks (Google ADK, CrewAI, LangGraph) are integrating A2A. Proceed with curiosity and caution.
Split layout: A2A description and architecture diagram on left, A2A vs MCP comparison on right
Comparison across six criteria: Speed to first value (days vs weeks), Customization depth (rule-based vs full flexibility), Integrations (rich ecosystem vs unlimited), Governance (built-in vs full control), Observability (basic vs advanced), Cost (lower entry vs higher upfront).
Two-row comparison table with six decision criteria columns
Security architecture: SOC at center with EDR, XDR/SIEM, Application Delivery Controllers, CloudSec, SASE, IAM/PAM, Data Sec/DLP, GRC, Offensive Security. Three key points: SOC needs agent telemetry, control planes must evolve, organizations must secure identity/data/compliance.
Security operations architecture diagram with SOC center, surrounding security layers, and three key points
Questions courantes sur cette diapositive et le contenu de présentation sous-jacent.
This is BCG AI Platforms Group's comprehensive briefing on building effective enterprise AI agents, published November 2025. It covers the full lifecycle from design through deployment, with practical frameworks for agent architecture, platform selection, and governance based on BCG's experience delivering 300+ agents.
The five key blockers are: (1) Brownfield integrations with legacy systems, (2) Unreliable enterprise data, (3) Lack of evaluation frameworks, (4) Governance and audit overhead, and (5) OpModel and scale frictions. Notably, the limiting factors are not LLM capabilities but enterprise processes and systems.
BCG defines five horizons: H0 Constrained agents (at scale today), H1 Single agents (adoption rising), H2 Deep agents with orchestration (current focus), H3 Role-based agent teams (very early), and H4 Agent mesh (early R&D). Enterprises should focus on building up to Horizon 2 today.
The 14 components are: Agent dev lifecycle, Data platform, Memory, Evaluation, Agent orchestration, Prompt tuning & iteration, Agent platform build, Context engineering, AI Gateway, Environment design, Low vs pro code balance, Enterprise LLMOps, Failure modes management, and Regulatory & compliance.
BCG recommends a decision tree: If the use case is not differentiating, buy (Adopt). If you have limited resources, buy and configure (Adapt). Only build (Assemble) when the use case is differentiating and you have the engineering capability. Most enterprises will end up with a hybrid approach.
An ADC is BCG's standardized template for defining agent scope. It includes the agent-achievable goal, success metrics, inputs/outputs, required skills and capabilities, fallback behavior, and trigger type (reactive/proactive, user-led/system-led). ADCs ensure alignment between business targets and technical implementation.
MCP (Model Context Protocol) enables agents to discover and call tools and access resources, while A2A (Agent-to-Agent protocol by Google) handles dialogue, coordination, and state sharing between agents. They solve different layers of the AI tech stack and are complementary, though both are still evolving.
It dedicates significant coverage to security, including six categories of agent failure modes (identity, data, orchestration, reasoning, governance, operational), a security control plane architecture for SOC integration, and detailed mitigations for each failure type. The key principle is to engineer trust, compliance, and resilience by default.
Create Your Own Slides
Turn your ideas into professional presentations in seconds with 2slides AI.
Référencez des conceptions professionnelles, choisissez votre style et générez des diapositives avec un rendu de texte parfait. Alimenté par Nano Banana—commencez à créer votre présentation maintenant.
Your AI Agent for slides. Save time, shine faster with intelligent presentation creation.
© 2026 2slides. All rights reserved.