AI ENGINEERING / AGENTS & ORCHESTRATION
Agents & Orchestration
Building agents that ship, not demo: anatomy, orchestration patterns (single-loop to LangGraph graphs), tools and actions, and the production discipline — composed across Agentforce, LangGraph, Claude, and MCP.
Foundation · 2
Production note
Agent gotchas: how a demo dies in production
An AI agent demo is a magic trick: scripted inputs, a friendly path, an audience that wants to believe. A production agent is an engineering problem — reliable on inputs nobody wrote, bounded in cost, governed on every action, accountable to a human. Ten gotchas that kill agents after the demo, each with the question to answer first and the cost of getting it wrong.
Decision framework
Agent Style Guide: the bar an agent clears before it ships
The opinionated rules Cleon applies to every agent — the first decision (agent, workflow, or single prompt), the production checklist an agent clears before it ships, and how we compose Agentforce, LangGraph, Claude, and MCP to the job rather than pick a camp. The discipline document that turns the gotchas into a gate and the principles into practice.
Reference · 5
Reference
What is an agent? The anatomy of a system that decides
What an agent actually is, part by part: a model, instructions, tools, memory, and a control loop that runs perceive → reason → act → observe. How an agent differs from a workflow, a chain, and a single prompt — not as rivals, but as different shapes for different jobs — and the honest test for when you need an agent at all: only when the path can't be enumerated ahead of time. Establishes the vocabulary the rest of this subcategory uses.
Reference
Orchestration patterns: from a single loop to a graph
The agent orchestration patterns that actually hold in production — the single-agent ReAct loop, supervisor/worker, multi-agent collaboration, graph-based state machines, and routing/handoff — each with where it fits and its cost, latency, and reliability trade-off. Plus the honest warning that every agent you add is failure surface you now own, and where Agentforce's Atlas Reasoning Engine sits as the managed-reasoning instrument.
Reference
Tools and actions: giving an agent the ability to act
How an agent acts: tool (function) calling, where the tool name, description, and typed schema are the interface the model reasons over. Designing safe tools — least privilege, argument validation, idempotency, and an approval gate plus kill switch on consequential actions. Agentforce Actions (Flow, Apex, Prompt Template) inside the platform security model, and MCP as the open protocol for connecting models to tools across systems. Composed, not ranked.
Reference
Agentforce agents: the platform-native path
The Salesforce-native path as one instrument in the kit — the right one when the work lives in the security model and needs governed, auditable actions on customer data (principle 7). How an Agentforce agent is assembled: Topics that scope the jobs, Instructions that steer behavior, the managed Atlas Reasoning Engine that plans over them, Actions that act, grounding through Data 360, and the Einstein Trust Layer doing the governance. What you own and what the platform owns — and where the work hands off to an external agent.
Reference
External agents: LangGraph, Claude, and the loop you own
The off-platform path as one composable instrument — LangGraph for orchestration, the Claude API for the reasoning core, MCP for tool interop — and the thing that defines it: when you go external, you own the control loop, the state, the grounding, the security model, the governance, and the audit that Agentforce hands you for free. The right call when the work is off-platform, spans models, or needs a capability Salesforce does not reach — and complementary to the platform path, not a rival to it.