All notes
May 26, 202612 min readai-agentscopilot-studiolanggraphorchestrationarchitectureengineering

Four agent patterns recur regardless of vendor stack

Four agent patterns recur regardless of vendor stack

Every vendor case study now claims an agent win. After reading a few dozen back to back, the same handful of shapes keep falling out of the laundry, and almost none of them are about the vendor. The platform underneath is interchangeable plumbing.

Key takeaways

  • Four agent shapes recur across every credible case study: deterministic spine, embedded copilot, grounded Q&A, autonomous-with-approval.
  • The pattern is portable. The platform is governance tax you pay once and forget.
  • Gartner expects over 40% of agentic AI projects canceled by 2027. Pattern discipline is the difference between the 60% and the 40%.
  • The SMB version of every Fortune 500 demo runs under 200 dollars a month on Copilot Studio credits, n8n, or the Anthropic API.
  • Pick the pattern first. Pick the vendor second. Reverse that order and you ship a demo, not a system.

In this article

Pattern one: the deterministic spine with LLM steps inside

The most common shape across the field looks like a flowchart with a few LLM nodes welded in. A trigger fires, the system gathers data, an LLM reasons over a narrow prompt, the result feeds a downstream branch, a final step writes back to a system of record. The LLM is a contributor inside a deterministic harness, not the decision-maker that drives the harness.

Anthropic calls this "prompt chaining" plus "routing" in Building effective agents, the December 2024 essay that is still the canonical taxonomy. Google's Agent Development Kit ships Sequential and Loop workflow templates with the same skeleton. LangGraph's tutorial library mirrors the taxonomy one-to-one and adds the durable state graph as the meta-pattern. Microsoft's Copilot Studio Workflows is the same pattern dressed in Power Platform clothes. Four independent camps, four vocabularies, one diagram.

Replaying the Microsoft Power Platform session on real-world case studies, the Signetic prior-authorization agent is exactly this shape. An incoming email triggers the workflow. The system verifies patient identity, queries Dataverse via an MCP server, generates a payer-specific form, emails the requester for approval, then dispatches to the insurer. The LLM does the form-field interpretation and the identity reasoning; everything else is plain orchestration.

For a 60-person logistics firm running on n8n self-hosted (under 50 dollars a month including a small VPS), the same shape lands as: webhook from your TMS fires when a shipment status changes, an LLM node classifies the customer email asking about it, a branch decides whether to auto-reply, draft a reply for human review, or escalate to dispatch. Monday step: open n8n, copy the "Customer email triage" template from the n8n AI agent examples blog, swap your Anthropic API key in, point the trigger at your shared inbox, and let one operations lead grade ten outputs against historical replies before you turn on auto-send.

💡 If your agent design includes "the LLM decides what tool to call next at every step," you are not in this pattern. You are in pattern four, and you should know it.

This pattern's loss case is interesting. When the deterministic spine itself becomes the differentiator, the platform IS the pattern. Temporal's durable execution, Copilot Studio's tenant-scoped audit, and AWS Step Functions plus Bedrock AgentCore are not interchangeable substrates; they are commitments. I argued the convergence at length in Copilot Studio Workflows is the spine LLM agents needed; the takeaway here is sharper. You can pick any of the five spines, but pick deliberately.

Pattern two: the embedded copilot inside the tool of record

The second pattern is the one that almost nobody talks about and that determines whether the rest of the work survives contact with users. The agent has to live inside the application the user already opens. A chat icon in the existing screen, a side panel in the existing tool, a contextual button on the existing record. Not a new tab. Not a new login. Not a new workspace.

Signetic's billing-ops agent puts a chat icon directly inside the model-driven Power Apps screen the operators already use eight hours a day. Afni's SMART-goal evaluator runs as a Copilot bot inside Microsoft 365 because their employees already live there. Both teams report that the embedding decision moved adoption more than any prompt tuning. The Afni team explicitly says their complex semantic-search and MCP-integrated agents got "low traction" while a simple bot inside the daily tool hit roughly 3,000 quarterly users by Q1 2026, per the case-study session on the Microsoft Power Platform channel.

The pattern works because context switching is the most expensive part of the workflow you are trying to improve. If you save ten minutes of debugging but cost two minutes of tab-finding, app-switching, and re-authentication, you have not actually shipped a productivity win, you have shipped a science project.

The SMB version. A 120-person regional accountancy firm running QuickBooks Online and a Microsoft 365 Business tenant ships a Copilot Studio agent that answers "why does this client's reconciliation not match" inside the Outlook side panel where the bookkeepers spend most of their day. Capacity pack at 200 dollars a month covers 25,000 messages, which is plenty for a team of 12 daily users. Monday step: open the Copilot Studio maker portal, create a new agent, connect it to a SharePoint folder with your reconciliation SOPs and the last six months of cleared statements, and publish to the Outlook copilot extension. Do not build the QuickBooks API connector yet; ship the Q&A first, measure usage for two weeks, then add the connector if usage justifies it.

The loss case here is uncomfortable for the pattern-over-platform thesis. The "tool of record" is rarely vendor-neutral. If your operators live in Salesforce, your agent has to live in Salesforce; if they live in SAP, your agent has to live in SAP. The pattern survives, the implementation cost does not. Vendor lock-in at the embedding surface is real.

Pattern three: live-data grounded Q&A

The third recurring shape is the one most vendors mislabel as "RAG" and most teams underbuild. The agent answers questions by combining live structured queries against a current system of record with curated unstructured knowledge (SOPs, policy docs, schema documentation). Neither half alone is enough.

Anthropic's taxonomy buries this inside "routing" plus tool use, which undersells it. The structured retrieval thread is well covered in Structured retrieval beats vector RAG for enterprise agents; the version that survives in production combines a SQL or MCP query against the live data layer with a retrieval step over the rulebook that explains what the data means. Signetic's billing agent only became useful when it stopped restating error codes ("rejection code 76, plan limitation exceeded") and started reasoning over both halves: the patient's actual annual benefit history from Dataverse plus the payer's interpretation of code 76 from the ingested SOPs. The second version cut the 30 to 45 minutes per rejected claim down to seconds.

A common SMB instance. A 45-person specialty distributor running NetSuite and Confluence ships an internal "why was this order held" agent. The structured query hits NetSuite via a small FastAPI wrapper around the SuiteQL endpoint; the unstructured side ingests the credit-policy and trade-compliance Confluence space. Total stack: Anthropic API for the reasoning, a 20-line MCP server in front of NetSuite, a Confluence connector via a low-cost RAG service. Realistic monthly cost: under 150 dollars at single-digit daily users. Monday step: list every "why did the system do this" question your order ops team Slacks about in a week, pick the top three, write the SuiteQL for each, and stop. Do not generalize; ship answers to those three first.

The pattern test: if your "agent" only has the SOPs and no live data, you have built a chatbot. If it only has the live data and no SOPs, you have built a SQL prompt with extra steps. Both halves are mandatory.

# Minimal grounded Q&A agent config (vendor-agnostic shape)
agent:
  name: order-hold-explainer
  model: claude-haiku-4-5
  system_prompt: |
    You answer "why is this order held" by combining:
    1. The structured query result from NetSuite (current state).
    2. The credit-policy document context (what should be true).
    Always cite the rule and the data point. Never speculate.
  tools:
    - name: netsuite_order_status
      type: mcp
      endpoint: https://internal-mcp.example/netsuite
      schema: order_id -> status, hold_reason, credit_limit_used
    - name: credit_policy_search
      type: vector
      collection: confluence_credit_policy
      top_k: 3
  guardrails:
    - require_citation: true
    - max_tool_calls_per_turn: 4

Pattern four: autonomous workflow with a human approval gate

The fourth shape is the one that gets all the attention and almost none of the production deployments. A workflow runs end to end without a human, then halts at a designated approval moment before the irreversible step. Identity verification, data gathering, form generation, draft preparation, all autonomous. Submission to the external party, human approval.

This is Anthropic's "autonomous agent" shape with a deliberate handoff baked in. LangGraph implements it as a graph with an interrupt node. Google ADK calls it a Loop workflow with an exit condition. Copilot Studio implements it via Power Automate triggers with a designated approval action. Same diagram, four labels. The orchestrator-workers variant, where a planner LLM delegates to specialist sub-agents and the human approves the final synthesis, is the multi-agent flavor of this same pattern; I argued the model-routing case for that in Orchestrated specialists beat frontier LLMs, and the shape generalizes whether you orchestrate one specialist or seven.

The Signetic prior-authorization agent reads the inbound provider email, extracts patient identity, queries Dataverse, generates the payer-specific form, then emails the requester for human approval before submission to the insurer. The "human in the loop" is not oversight, it is a deliberate primitive placed at the single highest-stakes moment. Everything before it is fully automated; the human is the legal accountability owner for the irreversible action, not the data-entry resource.

The SMB version requires honesty. Full autonomous loops are dangerous when the operator team is small enough that one bad action takes down a customer relationship. A 30-person B2B SaaS company can ship an autonomous "new customer onboarding form generator" agent that drafts the contract from the deal record and emails the AE for approval before sending. They should not ship an autonomous "auto-respond to customer support tickets" agent at the same size, because the cost of one wrong reply is too high relative to the savings. Monday step: list the five workflows your team currently does that have a clean approval moment (a click, an email send, a signature). Those are your autonomous-with-approval candidates. Everything else is a pattern-three Q&A agent.

💡 The human approval gate is the cheapest insurance you will ever buy. Never remove it because the agent "got it right last 100 times." Get it wrong once on the 101st and you find out why it was load-bearing.

Where the pattern argument loses

Pattern over platform is a useful heuristic, not a law. Three places the argument breaks.

First, governance is platform. Entra Agent ID, Tenant Graph Grounding, audit log integration, and per-agent identity are not pattern features, they are platform commitments. The four shapes generalize; the governance plane underneath does not. I argued this in detail in Microsoft 365 ships agent inventory not observability and Stop deploying agents, start onboarding them; pick the platform you can live with for five years.

Second, the deterministic spine itself is sometimes the moat. If you commit to Temporal, you have committed to a specific durability and replay model that no other vendor matches. If you commit to Copilot Studio Workflows, you have committed to the Power Platform data model and the Microsoft identity plane. The portability of the pattern does not transfer to portability of the implementation. The spine is sticky for good engineering reasons.

Third, the embedded-copilot decision is locked to the tool of record. You cannot ship a Salesforce-embedded copilot to a HubSpot customer. The pattern is portable; the deployment surface is not. For agencies and consultancies, this is the line where "we ship the same agent everywhere" becomes a lie.

The Gartner floor and what it changes

Gartner's June 2025 forecast is the contrarian anchor every honest agent post should cite. The headline number, verbatim: "Over 40% of Agentic AI Projects Will Be Canceled by End of 2027". The underlying poll surveyed 3,412 webinar attendees in January 2025; 19% reported significant agentic AI investment, 42% conservative, 8% none, and 31% wait-and-see. Gartner also estimates "only about 130 of the thousands of agentic AI vendors are real," which is their plain-English definition of "agent washing."

The pattern argument is not a way around this floor. It is the survival mechanism for being in the 60%. The projects that get canceled are the ones that picked a vendor first, then went looking for a problem the vendor could solve. The projects that survive picked a problem first (an actual repeating task with measurable cognitive cost), then picked the shape (one of the four), then picked the cheapest vendor that supports the shape with the governance plane the business needs.

That is also why the SMB case is so important. A 200-person company that picks Copilot Studio for 200 dollars a month plus a one-week build is not in the cancellation cohort, because there is nothing to cancel; the burn rate is too low to register on a CFO's quarterly review. The cancellations come from six-month, half-million-dollar agentic transformation programs that never picked a shape.

What to do Monday

Six concrete steps for any team between two and 200 people considering an agent project this quarter.

  1. Skip the vendor selection meeting. Hold it after you have picked the shape.
  2. Pick one repeating task that costs cognitive load (not volume). Time it with a stopwatch. Write down what "good enough" looks like in one sentence.
  3. Classify the task into one of the four shapes. If you cannot, the task is not ready for an agent; it is ready for a better runbook.
  4. Pick the cheapest vendor that supports the shape AND lives inside your existing tool of record. For most Microsoft shops that is Copilot Studio at 200 dollars a month. For Google Workspace shops that is Gemini for Workspace. For neither, n8n self-hosted plus the Anthropic API.
  5. Ship the first version in two weeks against synthetic data, not your real data. Measure latency, output quality, and one operator's read-aloud reaction before any rollout.
  6. Set a kill criterion before launch. "If usage is below X queries per active user by week six, we sunset it." This is the Gartner cancellation cohort's missing step.

The pattern argument and the platform argument are not in conflict. Patterns describe what the agent does; platforms describe where it lives. The mistake almost everyone makes is shopping for the platform before naming the pattern. That order is what produces the 40% cancellation rate and the agent-washing pile.

If you are working through one of these four shapes at SMB scale, I would genuinely like to compare notes on what your unit economics look like and where your governance line landed. The patterns are stable; the local realities are not, and that is where most of the interesting engineering ends up.