| The Agentic Enterprise

The Agentic Enterprise represents a fundamental shift in how companies use AI. It moves from passive tools that require constant human direction to autonomous agents that sense, reason, and act on their own while staying aligned with human intent. It’s an organization where humans, agents, and platforms work together inside governed business systems to deliver outcomes none could achieve alone.

This document is a companion to the Well-Architected Framework. The framework's five pillars — Trust, Reliability, Operational Excellence, Resource and Cost Optimization, and Fairness — provide the foundational guidance that applies to all Salesforce solutions. This overview explains what changes when solutions become agentic, and points you to the pillar-by-pillar detail.

Agentic systems combine large language models, retrieval-augmented generation, function calling, and orchestration patterns to create capabilities that adapt to context rather than following rigid programmed paths. Agents combine probabilistic reasoning (LLM inference) with deterministic execution (workflows and orchestration) to enable both adaptability and governance.

For architects, this behavior introduces design considerations across every pillar. Agents operate with non-deterministic behavior in their reasoning layer, which requires new patterns for reliability, monitoring, and control. Agent autonomy demands enhanced security boundaries and Human-in-the-Loop oversight. Multi-agent coordination creates emergent complexity requiring deliberate orchestration. The Agentic Enterprise is not simply adding AI features to existing architectures — it reimagines how systems are designed, deployed, and governed.

Done well, this combination creates real business value: agents handle complex, multi-step workflows that previously required human intervention, synthesize information across sources, and scale expertise across the organization. It also introduces challenges that demand deliberate design. Non-deterministic behavior complicates testing, monitoring, and error handling. Autonomy raises questions of control, accountability, and safety. Cost structures shift from fixed infrastructure to variable inference consumption. Architects must balance autonomy against risk, innovation against control, and capability against cost.

A fundamental distinction in agentic architecture is whether an agent assists a human (copilot pattern: suggest, recommend, draft) or acts autonomously (agent pattern: decide, execute, complete). Copilots require human approval for state-modifying actions; agents operate independently within permission boundaries. That distinction determines trust requirements, observability needs, and oversight patterns. Moving from assists to acts is an architectural shift, not a configuration change — it requires re-evaluating every pillar through the lens of autonomous operation.

The Agentic Enterprise is an organization where humans, agents, and platforms work together inside governed business systems to deliver outcomes none could achieve alone. This three-part model shapes every architectural decision:

Humans provide oversight, judgment, and intervention when agent capabilities fall short or when the stakes require human accountability. Human-agent collaboration lets people focus on high-value judgment while agents handle routine execution and information synthesis. Humans stay in control at the system level: they define the boundaries, and agents decide and act within them.
Agents provide intelligent automation, natural-language interfaces, and adaptive decision-making. Agents are not standalone features but integrated participants in business workflows. They sense context from governed data, reason about appropriate actions using probabilistic and deterministic techniques, and act through business workflows and external integrations.
Platforms provide the governed infrastructure that makes agentic work possible — accumulated business logic, unified data, orchestration, and collaboration infrastructure. The platform distinguishes enterprise-grade agentic systems from ungoverned AI experiments: it enforces permissions, maintains audit trails, applies compliance rules, and keeps agents operating within organizational governance.

Remove humans and you lose accountability; remove agents and you lose intelligence; remove platforms and you lose governance. The Agentic Enterprise requires all three as a unified system.

Any agentic architecture — on any technology stack — must supply a common set of capabilities. An agent needs trusted data to reason on, business logic it can safely act through, governance over its own lifecycle, a shared understanding of what data means, and a path to escalate to humans. These are architectural requirements, not products: where Salesforce provides part of the stack, the remaining capabilities still require attention.

Salesforce delivers these capabilities as an integrated set. Treating them as a system makes the dependencies explicit: weaken any one and agents are limited in a predictable way. This section describes each capability, why it matters for agents, and how Salesforce provides it.

Agents require governed, verified data to reason effectively — AI models know patterns from training data, not a company’s customer records, product catalog, or transaction history. This capability closes that gap by grounding agents in data that is accurate, permissioned, current, and traceable, rather than arbitrary web content or unverified sources.

Current operational data powers time-sensitive decisions: a commerce agent answering "What's my order status?", a service agent surfacing open cases, or a sales agent ranking opportunities that close this quarter.
Historical data — for example, large datasets held in Data 360 — supports trend analysis, forecasting, and learning from past patterns.
Federated access lets agents reason across data wherever it lives. It reduces duplication for connected sources and presents a unified view.

Salesforce provides this through the Data 360 portfolio.

Architectural implication: Agent quality depends on data quality. Invest in data governance, classification, and lineage. An agent that surfaces incorrect data erodes trust faster than one that says "I don't know."

An agent that can only answer questions is a copilot. An agent that can create records, update opportunities, send communications, and trigger automations is autonomous. This autonomy lets agents act rather than merely assist — it invokes existing, well-tested business processes instead of reimplementing them in generated code.

Agents translate natural-language intent into standard business operations rather than requiring users to write code.
Agents delegate to encapsulated multi-step processes (for example, a refund flow that handles credit checks, inventory updates, and notifications).
As business rules evolve, agents inherit the changes automatically — provided that the logic lives in the workflow and not mirrored in agent instructions.

Salesforce provides this capability through Customer 360 business logic and platform automation.

Architectural implication: Design agents to invoke existing workflows, not replace them. Agents calling proven automations are more reliable than agents reimplementing business logic through generated code.

Agents need governance from development through deployment, monitoring, and retirement. Without it, ungoverned agent proliferation creates shadow AI: agents with unclear permissions, no audit trails, untested behavior, and unknown cost. This capability ensures that agents are built with guardrails, deployed through approval gates, monitored for drift, and retired when no longer needed.

Development tooling generates initial configurations from natural-language descriptions and enforces guardrails (permission validation, subagent scope) at design time.
Runtime orchestration manages agent invocation, permission enforcement, audit logging, and failure handling.
Reusable capabilities let teams adopt pre-built agents and actions — including vertical, domain-expert capabilities — rather than building every agent from scratch.
Session observability stores agent interactions, reasoning steps, and outcomes for analytics, debugging, and drift detection.

Salesforce provides this capability through Agentforce Studio, Agent Fabric, and AgentExchange.

Architectural implication: Treat agents as managed assets, not one-off scripts. Governance at the system level prevents agent sprawl.

Agents querying data need to understand semantics: what "revenue" means, which field is "customer name," how tables relate. Without a shared semantic definition, agents generate queries that use the wrong fields, misinterpret nulls, or violate business rules. With one, every agent queries through governed definitions and returns consistent, correct results — with fiscal-calendar and revenue-recognition logic living in the definition, not in agent prompts. This layer operates within the platform's native security model: access is governed by the platform's own row-level and field-level controls, not re-implemented in the semantic layer. As a result, agents are bound by the same data permissions the platform enforces.

Salesforce provides this capability through Tableau Semantics, a governed semantic layer integrated with Tableau Next and Data 360.

Architectural implication: Define the semantic layer before deploying analytical agents. Agents querying raw tables create governance gaps and inconsistent results.

Fully autonomous agents without human oversight create compliance risk, accountability gaps, and user distrust. This capability keeps humans in control: agents escalate when uncertain, request approval for high-impact actions, and stay transparent about their reasoning.

Approval workflows let agents request human sign-off before executing consequential actions (issuing a refund, closing an opportunity, deleting data).
Persistent interaction history logs intent, data accessed, reasoning steps, and actions taken — enabling audit, debugging, and continuous improvement.
Escalation patterns hand off to human specialists with full context when an agent lacks confidence or hits an edge case.

Salesforce provides this capability through Human-in-the-Loop approval and escalation workflows with persistent, auditable interaction history.

Architectural implication: Design explicit escalation rules up front. Define which decisions require human approval — financial thresholds, irreversible actions, regulated data — and implement those workflows before deploying autonomous agents.

These capabilities are interdependent. An agent draws on trusted data to ground its reasoning, acts through business logic, operates under lifecycle governance, queries through shared semantics, and escalates to humans when needed. Remove trusted data and agents hallucinate; remove business logic and they can only answer, not act; remove governance and they proliferate into shadow AI; remove shared semantics and their queries drift; remove human escalation and they act without oversight. An API-first consumption model — AIforce — lets agents reach these capabilities through consistent programmatic interfaces (API, MCP, and CLI) rather than integrating separate systems one by one.

The Well-Architected Framework pillars remain the foundation for agentic systems — agents still operate within governor limits, require proper access controls, need monitoring, consume resources, and serve users equitably. Start from the core pillar guidance, then apply the agentic considerations each pillar's companion adds.

Core pillar guidance:

Trust — Shared Responsibility Model, four-layer access control (org/object/field/record), encryption, OAuth flows, audit trails, compliance frameworks
Reliability — governor limits with a recommended operational buffer (the 70% ceiling is a widely cited community best practice, not an official Salesforce specification), async processing, circuit breakers, capacity planning, multi-org patterns, disaster recovery
Operational Excellence — Event Monitoring, proactive monitoring, DevOps practices (source-driven development, CI/CD), automation, incident management, DORA metrics
Resource and Cost Optimization — SOQL optimization, data-skew prevention, code organization, packaging strategies, performance monitoring, TCO modeling, build vs. buy, license optimization, cost monitoring
Fairness — accessibility (WCAG 2.2 AA), non-discrimination patterns (sharing rules, FLS), privacy architecture, AI ethics governance

Core trust patterns (Shared Responsibility Model, least privilege, encryption, OAuth) remain foundational. Agentic systems add:

Agent identity and authentication — agents can use JWT-based authentication rather than static API keys, which enables per-agent audit trails and granular permission tracking
User identity propagation — when agents invoke external systems on a user's behalf, propagate the user's identity (not just the agent's) so downstream systems enforce user-level permissions and audit trails
Permission boundaries — least privilege for agents, permission inheritance from the running user, explicit agent permissions, and validation at delegation boundaries
Human-in-the-Loop for consequential decisions — approval workflows for high-impact or irreversible actions and regulated data
Explainability — agents explain their reasoning, cite sources for factual claims, and make the data and actions they took transparent
Compliance for autonomous systems — adhere to the EU AI Act's risk classification (differentiating limited vs. high-risk deployments) and to sector-specific regulations such as HIPAA and functional financial-services law; maintain rigorous consent management for agent-driven processing

Why this matters: Agents acting autonomously without proper trust boundaries create security vulnerabilities, compliance violations, and user distrust. The core Trust pillar provides the Shared Responsibility Model and four-layer access control; the agentic variant adds optional JWT-based agent authentication, HITL approval gates, and explainability.

To learn more, see Agentic Enterprise Trust.

Core reliability patterns (governor limits, async processing, circuit breakers, capacity planning) remain foundational. Agentic systems add:

Handling non-deterministic reasoning — the same input can produce different outputs; design for variance with confidence scoring, validation checks, and fallback strategies
Graceful degradation — when inference fails or returns low confidence, degrade to simpler capabilities rather than failing completely
Orchestration failure handling — multi-agent workflows need failure isolation, retry strategies, and partial-result handling so one specialist agent failing stays isolated instead of cascading
Model performance SLOs — define acceptable latency, accuracy, and availability targets for agent services
Circuit breakers for agent coordination — prevent cascading failures when one agent experiences errors or excessive latency

Why this matters: Probabilistic agent behavior means that deterministic reliability patterns aren't sufficient. The core Reliability pillar provides async patterns and circuit breakers for external integrations; the agentic variant adds graceful degradation for inference failures and orchestration failure handling for multi-agent coordination.

To learn more, see Agentic Enterprise Reliability.

Core operational excellence patterns (Event Monitoring, DevOps, automation, incident management) remain foundational. Agentic systems add:

Agent Development Lifecycle (ADLC) — manage agents across their full lifecycle, from design and testing through deployment, monitoring, and tuning
Observing probabilistic systems — capture reasoning steps, confidence scores, data sources accessed, and decision rationale, not just input→output
Drift detection — monitor for performance degradation from data-distribution shifts, business-rule changes, or upstream model updates against behavioral baselines
Agent versioning and deployment — gradual rollout, A/B testing, rollback, and version control for prompts and configurations
Incident response for agent failures — distinguish model failures, orchestration failures, and data failures for targeted remediation

Why this matters: Non-deterministic behavior makes observability harder. The core Operational Excellence pillar provides Event Monitoring and DevOps practices; the agentic variant adds ADLC, drift detection, and agent-specific observability.

To learn more, see Agentic Enterprise Operational Excellence.

Core resource and cost optimization patterns (SOQL optimization, governor limits, code organization, performance monitoring, TCO modeling, build vs. buy, license optimization, cost monitoring) remain foundational. Agentic systems add:

Inference latency optimization — streaming responses, parallel execution, caching, and prompt optimization
Token economy — every call, retrieval, and reasoning step consumes tokens; design context-management strategies (summarization, selective retrieval) for limited context windows
Memory retrieval optimization — efficient vector search and semantic retrieval so RAG patterns don't create latency bottlenecks
Multi-agent latency management — parallel specialist execution, async delegation, and timeout budgeting to prevent sequential agent chains from accumulating latency
Agent modularization — decompose monolithic agents into specialist agents for reuse, independent scaling, and targeted optimization
Consumption-based pricing — unlike per-user licensing, agent costs scale with usage, requiring different budgeting and forecasting
Agentic Work Units (AWUs) — measure spend against the work that agents complete, not raw token consumption alone, and tune consumption against the value delivered
Build vs. buy for agentic capabilities — evaluate building differentiated capabilities against adopting commodity ones
Agent ROI measurement — track business outcomes against agent operational costs

Why this matters: Token consumption and inference latency are new resource constraints, and agentic cost models differ fundamentally from infrastructure costs. The core pillar provides governor-limit guidance, SOQL optimization, and the TCO framework; the agentic variant adds token economy, inference latency optimization, consumption-based pricing management, and Agentic Work Units for measuring cost against the work agents complete.

To learn more, see Agentic Enterprise Resource and Cost Optimization.

Core fairness patterns (accessibility, non-discrimination, privacy, AI ethics governance) remain foundational. Agentic systems add:

Explainability — agents explain why they decided, what data they used, and what alternatives they considered. (The Trust pillar covers explainability as an audit and transparency control; Fairness covers it as a user's right to understand a decision that affects them.)
Contestability — users can challenge agent decisions, request human review, and understand the appeals process
Bias detection and mitigation — test with diverse inputs and monitor for disparate outcomes across demographic groups
Human oversight proportional to impact — high-stakes decisions require Human-in-the-Loop; low-stakes decisions may operate autonomously
Equitable agent-driven experiences — serve all users effectively regardless of language proficiency, technical expertise, or accessibility needs

Why this matters: Autonomous agents making decisions that affect people raise fairness stakes. The core Fairness pillar provides accessibility standards and non-discrimination patterns; the agentic variant adds explainability, contestability, and proportional human oversight.

To learn more, see Agentic Enterprise Fairness.

When architecting agentic solutions:

Start here for the conceptual model: the capabilities agents require, and how the pillars apply to agents.
Read the core pillar guides for the foundational approaches that apply to all Salesforce solutions.
Read the agentic pillar companions for the design detail specific to agents.

Build on proven platform patterns, then address the considerations agents introduce. The core pillars provide the foundation, the agentic companions provide the detail, and this overview ties them together.

The capabilities and pillars above describe how to architect an agentic system. Putting that system into production requires a standing governance structure: a Center of Excellence (CoE). In the unified system of humans, agents, and platforms, the CoE gives humans control. The CoE defines agents' boundaries, decides what reaches production, and aligns agentic work with business intent and regulatory requirements. A CoE is the difference between governed agentic systems and ungoverned experiments that drift into shadow AI — agents with unclear permissions, no audit trail, and unknown cost.

Autonomy makes every governance decision consequential. The CoE helps teams make those decisions deliberately and enforce them consistently, rather than resolving them one team at a time.

A CoE brings business, IT, and compliance together around a shared backlog and a shared definition of ready. Its membership spans the perspectives an agentic decision touches:

An executive sponsor holds budget authority and clears organizational blockers.
Business leads translate strategy into priorities and own the backlog.
A program office and data stewards connect agentic work to broader initiatives and assess data integrity and security.
Architects, admins, and developers own the data model, integration patterns, and delivery cadence, and surface technical constraints before work begins.

Agents ship, change, and drift faster than traditional software. To keep governance aligned with delivery, the CoE runs on an accelerated, asynchronous-first review cadence. The rhythm tightens compared to a conventional CoE, and asynchronous review becomes the default working mode:

Continuous, asynchronous review is the primary mode: members stay aligned in a shared channel as changes land, not only at scheduled meetings.
Weekly operational reviews confirm that in-flight changes stay compatible with active agents and integrations — a faster beat than the monthly or quarterly reviews a slower delivery pace would allow.
Monthly strategic reviews weigh the backlog against business priorities and assess readiness against the current data-quality baseline.

The CoE makes explicit decisions about who approves changes to the objects, fields, and automations that agents depend on; who owns priority when requests compete; when to retire technical debt; and which business metrics define success.

An agentic-ready CoE governs across each pillar. The core pillar guides provide the foundational controls; the CoE is where they become enforced, observable practice.

Trust — Object-, field-, and record-level security governs the data that agents use. Agent-level access controls limit the data and actions that each agent can access. Identity, least-privilege, and threat modeling are embedded in the agent's design. See Trust and Agentic Enterprise Trust.
Operational Excellence — Trace and audit logs capture agent decisions, actions, and outputs. Monitoring dashboards review performance and alignment against goals across the Agent Development Lifecycle. See Operational Excellence and Agentic Enterprise Operational Excellence.
Reliability and Resource and Cost Optimization — Specification, test generation, feedback loops, and deprecation govern the full agent lifecycle. Rate limiting, resource controls, and remediation strategies contain the effects of agent errors. See Reliability and Resource and Cost Optimization.
Fairness — Human-in-the-loop checkpoints let people intercept or review consequential actions. Escalation paths and staff training prepare people to review and override agentic workflows. See Fairness and Agentic Enterprise Fairness.

A CoE is ready to govern agentic workloads when these conditions hold:

Policy — Access and action policies for agents are defined, enforced, and auditable.
Observability — Monitoring and audit tools support real-time and retrospective reviews of agent behavior.
Secure by design — Security, privacy, and compliance are built into agentic workflows from the start.
Lifecycle — A structured process governs onboarding, updating, and retiring agents.
Human oversight — Reviewers handle exceptions and use feedback to improve agentic workflows.

Confirm these four foundations before deploying your first production agent:

A documented data-quality baseline, reviewed on a regular cadence.
A formal schema-change approval process with a named owner and recorded sign-off.
A maintained technical-debt register, reviewed at the strategic cadence.
An AI governance policy covering data access, agent scope, and audit requirements.

Architectural implication: Establish the CoE and confirm these foundations before deploying autonomous agents. Governance that is built-in from the start scales with agent adoption. Governance retrofitted afterward competes with the sprawl it is meant to prevent.

See also: Deployment Approval Processes in the Agentic Enterprise Operational Excellence guide — the per-agent, go/no-go checklist that complements this section's organization-level readiness view.

Organizations beginning their agentic journey should:

Start with high-value use cases — focus initial agents on workflows with clear ROI; success builds momentum.
Build foundational capabilities — establish data governance, knowledge bases, and integration patterns.
Develop agent expertise — build skills in prompt engineering and agent architecture, even as low-code and natural-language tools lower the barrier to entry.
Establish a Center of Excellence — stand up the governance body that owns approval processes, safety testing, and monitoring before deploying production agents (see Organizational Readiness: The Center of Excellence above).
Iterate — plan for continuous refinement rather than a perfect initial deployment.
Measure value — track business outcomes, cost savings, and user satisfaction to inform investment.

The Agentic Enterprise is a transformational opportunity for organizations ready to embrace AI-powered workflows. Deliberate architectural design lets you realize it while managing risk and complexity.

Share your feedback on the Well-Architected Framework.