Deterministic vs Agentic: The Quiet Architectural Bet Every AI Agent Company Is Making

Every "AI agent" product on the market is making one of two architectural bets, and the founders usually can't articulate which. The bet decides whether your agent costs cents or dollars per run, whether it works the same way twice, and whether it will still be running a year from now.

It's worth naming.

The Two Camps

Fat harness, agentic. The LLM decides every step at runtime. Every run is a fresh plan. Every plan costs tokens. Every step is an opportunity for the model to go somewhere new.

Examples:

Claude Code, Cursor, Copilot agents (open ended coding work)
LangGraph (reasoning over a graph)
CrewAI (agents organized by role, +280% adoption in 2025)
AutoGPT (autonomous loops)
OpenAI's AgentKit

Thin harness, deterministic. The LLM designs the pipeline once, at build time. Then code runs forever. The model gets called only for the specific steps that actually need judgment. The trigger is deterministic. The data sources are scoped. The output goes somewhere predefined.

Examples (and this list is nowhere near complete):

HubSpot Breeze (Customer Agent on ticket creation, Prospecting Agent on deal stage, Data Agent in workflows)
Slack (daily channel recaps, thread summaries, scheduled digests)
Linear Triage Intelligence (auto triage, auto assign, duplicate detection, label suggestions)
Asana Smart Fields (AI generated custom field values on task creation)
Notion AI (summarize a page, "Ask Notion" Q&A across the workspace, meeting note formatting)
ClickUp (Project Manager Agent auto assigning tasks, Meeting Notetaker, Auto Prioritize)
Zoom AI Companion (post meeting summaries, action items, decisions)
Microsoft Teams Intelligent Recap (AI notes, chapters, speaker timelines, follow ups)
WaveAssist (GitZoid, GitDigest, WavePredict, WaveContent, and the rest of the assistant catalog, each running on a defined trigger and a defined job)

Look at almost any major SaaS shipping in 2026. The "AI features" tab is, with rare exception, a list of thin harness agents. Each one has a defined trigger, a scoped input, a predictable output, and a job small enough that the model can't wander out of it.

One approach puts the intelligence inside the loop. The other puts the intelligence behind the loop.

Neither is wrong. They're built for different jobs. The fat harness list above is short because the work is hard. The thin harness list is long because the work is everywhere.

When Fat Harness Wins

Fat harness is the right answer when the work is novel, open ended, or impossible to script in advance.

Coding is the canonical example. Every bug is different. Every codebase has its own conventions. Every fix requires reading files, running tests, reasoning about the output, and changing course. You can't write a deterministic pipeline for "fix the bug." You need an agent that re reads the situation at every step. That's why Claude Code, Cursor, and the Copilot agents are all fat harness, and that's why they work as well as they do.

The same applies to:

Open ended research and analysis ("dig into this question and tell me what you find")
Investigative tasks where the next step depends on the last step's output
Tasks where the human doesn't fully know what they want until they see what's possible
One off jobs where the cost of building a pipeline exceeds the cost of running the agent twice

If you tried to make Claude Code thin harness, you'd be writing a pipeline for a problem you can't predict. The whole point is that the model gets to plan as it goes, react to what it finds, and re plan when reality doesn't match.

Fat harness is genuinely awesome at this kind of work. It's not a worse architecture. It's a different one.

When Thin Harness Wins

Thin harness is the right answer when the work is scoped, repeated, and triggered. A defined job, a defined trigger, a defined output. Run it a thousand times this year.

Almost every AI agent shipping inside production SaaS today is thin harness. Once you know the shape, you start seeing it everywhere.

HubSpot Breeze (CRM). When a ticket is created, the Customer Agent runs. When a deal hits a stage, the Prospecting Agent runs. The Data Agent runs as a workflow step on a schedule. HubSpot's workflow engine handles the trigger, the data, and the routing. The LLM is called at the one step that needs judgment ("draft a reply to this ticket using these knowledge base articles"). Same shape, every fire. Charged per result.

Slack summaries. Daily recaps. Channel summaries. Thread catch ups. Each one is a fixed function: defined input (this channel, this date range), defined output (a structured summary), defined schedule (every morning). Slack's published number for time saved is over a million working hours. None of that comes from a fat harness loop replanning what to do each morning. It comes from the same pipeline running, reliably, on millions of channels.

ClickUp task agents. The Project Manager Agent auto assigns tasks based on owner expertise when a task is created. Meeting Notetaker turns a transcript into action items. Auto Prioritize sorts a backlog. Each agent has one job, scoped to one trigger. ClickUp's own docs draw the line clearly: "automations are deterministic and fast. AI agents are flexible but come with token costs that add up at scale." That cost arithmetic is why most production work in their stack runs deterministic.

WaveAssist agents. Every Monday at 9am, GitDigest reads the week's diffs and writes five role specific summaries. Every PR webhook, GitZoid reads the diff and posts a review. WavePredict runs forecasts on a schedule. WaveContent drafts on a brief. The full catalog (these are examples, not the whole list) follows the same shape: a defined trigger, a scoped job, the same pipeline running every fire. The expensive thinking happened once, when each pipeline was designed. Every run after is structured.

The pattern is the same across all four:

The trigger is deterministic (event, schedule, webhook).
The data sources are scoped, not "anything the agent can find."
The LLM is called at one or two specific steps where judgment is genuinely needed.
The orchestration, the routing, the validation, and the side effects are code.
The agent runs thousands of times per day with predictable cost and predictable shape.

The Reliability Argument

Thin harness isn't a stylistic preference for repeated work. The reliability data forces it.

The top coding models (GPT 5, Claude Opus 4.1) score about 70% on SWE-bench Verified and collapse to 23% Pass@1 on SWE-Bench Pro (Sept 2025, arxiv 2509.16941), the long horizon, multi file variant. On commercial subsets it drops under 20%.

Agentic loops on long, repeated tasks fail most of the time.

You cannot run a business on 23%. You can, however, run a business on a deterministic pipeline that calls a 70% reliable model for one well scoped step, validates the output, and retries. The surface area where the model can fail is smaller by construction.

That's why scoped agents (Breeze's Customer Agent, Slack's Summarizer, GitZoid's PR review) hit reliability numbers a fat harness loop never will. They ask the model to do exactly one thing it's good at, in a context it can't wander out of.

The Skeptical Read

The people with no stock in the outcome are waving the same flag for repeated production work.

Simon Willison (Jan 2025):

"I think we are going to see a lot more froth about agents in 2025, but I expect the results will be a great disappointment to most of the people who are excited about this term."

Hamel Husain:

"Be deeply skeptical of features that promise full automation without human validation… this stacking of abstractions often hides flaws behind a high score."

Neither is saying agents are useless. They're saying that betting your production reliability on a fat harness loop is, today, a bad trade.

The Anthropic Signal: Structure Over Slop

Watch what the labs build, not what they say.

Anthropic, the lab most associated with "agents" in the public imagination, keeps quietly making the same architectural choice: prefer structured, editable artifacts over freeform generation.

Claude Code is fat harness, but it emits code. Not vibes, not pseudocode. A real diff you can run, test, and revert.
Claude Design generates production ready HTML, CSS, and JavaScript, not images. The output is an editable artifact you can deploy to Vercel, hand to Claude Code, or open in a browser. The lab made an explicit bet that structured code beats generated pixels for design work.
Agent Skills (December 2025) are folders of instructions, scripts, and resources that agents load dynamically, shipped as a cross industry standard with Atlassian, Canva, Cloudflare, Figma, Notion, Ramp, and Sentry. Not a smarter agent. Codified, file backed building blocks.

The pattern is consistent. Even when Anthropic ships fat harness, the artifact is structured. Even when they ship a creative tool, the output is code. The bet is that production AI runs on structure, not on the model's mood.

Thin harness is one expression of the same bet, applied to the agent itself: make the workflow a structured artifact, and call the LLM only where you need its judgment.

The WaveAssist Bet

WaveAssist picked thin harness, on purpose, because the work we're built for is the work that runs every day, every Monday, every webhook, every commit.

Run the intelligence once. The model helps you design the pipeline at build time.
Run code forever. The pipeline itself is compiled, versioned, and cheap to execute.
Predictable cost. You're not paying the LLM to replan every Monday at 9am.
Predictable behavior. Same inputs, same outputs. No drift because the model woke up feeling creative.
Predictable uptime. Code doesn't change its mind. Nodes run. Schedules fire. Webhooks hit.

Every agent we ship (GitZoid, GitDigest, WavePredict, WaveContent, SentimentRadar, PatternAnalyser, and the rest) is a compiled pipeline, not a runtime loop. The expensive part happened once, at the start. Everything after is deterministic.

We didn't pick thin because fat is bad. We picked thin because the work we're shipping is repeated production, and that's the same architecture HubSpot, Slack, ClickUp, and Anthropic's Skills team picked for the same reason.

The Bottom Line

The agent space isn't splitting into winners and losers on model quality. It's splitting on architecture.

Pick by job:

Open ended, novel, exploratory. Fat harness. Claude Code is the canonical example.
Repeated, scheduled, scoped. Thin harness. Almost every production agent inside SaaS today.

The mistake isn't picking one camp. It's using a fat harness loop where a thin harness pipeline would do, or shipping a thin harness for a job that genuinely needs a model in the loop.

Pick your bet. Then ask your vendor which one they made, and whether it matches the work you're paying them to do. If they can't answer clearly, that is the answer.

推荐订阅源

DEV Community