Where are you in the loop? Four shapes of AI.

Someone at the next meeting is going to say "we're using AI for that." Maybe for ticket triage, maybe for contract review, maybe for the monthly sales rollup. The line will land, it'll sound impressive, and nobody will ask the follow-up that actually matters: how are you using AI for that?

That question matters because the shape of the deployment determines your risk exposure and your actual capabilities more than the model inside it does. The same model can show up in four very different shapes. You type a question into chat and read the answer. The same model suggests a rewrite of your email in Outlook, and you accept or edit it. The same model spends twenty minutes cleaning up a sales report while you're on a call, and hands you a draft. The same model runs a nightly pipeline that reconciles invoices with nobody at the keyboard. Four positions on the loop, four different relationships with the model. Each one changes what the AI can do for you and what can quietly go wrong.

The useful cut, once you strip away the product names and the vendor diagrams, is just this: where does the human sit in the review loop? That's the shape.

Ask

Ask is the shape most people understand when thinking about using AI. You type a question, the model replies, you read the answer, you decide what to do with it. Every exchange goes through you in real time.

Scenario

An analyst pastes a customer ticket and asks what's really being asked. A partner runs a clause past the model before flagging it for review. The cost of any single bad answer is low because you read it before you act on it.

Stakes

The stakes show up elsewhere. This is where your organization is quietly deciding what the AI can be trusted with. Every Ask interaction is someone forming a private opinion about whether to push this model into higher-stakes work. Most of your org is in this shape right now, and most of the trust calls driving your real AI strategy are being made here: by individual contributors discovering the model's utility, with no formal process behind them.

Assist

Assist is the shape most enterprise software is being rebuilt around. The AI lives inside the app you're already working in. The embedded Copilot sidebar in Word, Outlook, or Excel is the obvious example. You select something relevant, give a short instruction ("make this more formal", "summarize this thread", "draft a response"), and the model produces a result you accept, edit, or reject.

Stakes

Done well, this is a big productivity win. The trap is completion bias: the polished output is already on your screen, in the right format, in the right place. Rejecting it is more friction than accepting it. Editing it lightly is easier than thinking from scratch about whether the framing is even right.

That's how a hallucinated case citation ends up in a brief, a wrong figure ends up in a board memo, or a tonally-off line ends up in a customer email. When it happens, blame naturally lands on the model: it hallucinated, it was wrong, it made something up. The harder truth is that review got compressed into a glance, and a polished-looking output got accepted because rejecting it would have cost more than nodding did. Assist done right is where AI quietly starts speaking in your firm's voice. Done wrong, it's where your firm quietly starts speaking in the AI's.

Delegate

Delegate is where you define the work and hand off its execution. The model sequences the work, draws from the files and systems it's been given access to, takes multiple actions, and sets a result in front of you for review. You stay accountable for what ships, but you're no longer accountable for how it got built.

This is where the word "agent" finally starts fitting something specific. Delegate covers a spectrum. At one end, the workflow is well-defined: the work always pulls from the same sources, uses the same tools, and produces the same kind of artifact. At the other end, the work is open-ended: you give the agent a goal and it figures out which files to open and which tools to call as it goes. Both count as Delegate. The broader the work, the more the result depends on the agent's judgment at each step.

Scenario

You ask the agent to prepare a draft of next week's QBR deck. It pulls pipeline data from Salesforce, reconciles it against the forecast sheet, drafts the narrative slides, flags the three accounts that moved most, and hands you a deck. Twenty minutes, no keystrokes from you in the middle.

The failure mode is usually the integrations. An agent that sequences the work brilliantly but pulls from the wrong CRM view, or queries last quarter's data instead of this quarter's, produces a polished deck full of subtly wrong numbers. Model quality is the easy part. Whether the agent can reliably reach the right data, read it correctly, and act in the right systems is the hard part.

Stakes

Because the work happens out of sight, the only signal you have to catch a mistake is the final artifact. This is why a record of the agent's work matters as much as the output itself: every query it ran, every document it opened, every tool it called, every intermediate result it produced. In AI engineering this record is called a trace. Without it, a subtly wrong deck is indistinguishable from a correct one. With it, you can trace a wrong figure back to the query that produced it or the view the agent opened. If your Delegate tools don't give you traces, you're accountable for work you can't audit.

Automate

Automate is unattended operation. A scheduled job runs, or an incoming event triggers a workflow. No person at the keyboard, often no person aware the run happened until they check the logs or see the defined output the next morning.

Scenario

A nightly pipeline reconciles invoices against purchase orders, flags exceptions, and routes the clean ones for payment. It runs at 2am. By the time anyone looks, payments have been queued and exceptions auto-resolved.

The failure mode here is drift. The same inputs that produced clean outputs six months ago now produce slightly different ones. The vendor pushed a model update. The data schema shifted. The workflow operates on inputs it wasn't originally designed for. The system is still running. It's gradually getting less accurate in ways nobody is around to notice.

Stakes

Automate is where this gets most dangerous, because there's no one in the loop to notice in the moment. The next scheduled run, the next quarter-end reconciliation, the next audit: that's when the drift surfaces, often weeks or months after it started. The safety case is the config, the guardrails, and the alerting, all written before you turn it on. The logs are how you reconstruct what happened after.

Why shape matters more than model

On the benchmarks most people quote, the top models cluster within a few points of each other. Where they actually diverge is in multi-step work: whether the model can reliably call the right tools, recover cleanly when something goes wrong mid-task, and stay coherent over long stretches of work. A strong model that loses track partway through can lose to a weaker one that recovers from its own mistakes.

Shape is where that divergence lands, and where the stakes live. An Ask deployment can't damage anything in production. A Delegate deployment can miss a review gate if the reviewer isn't paying attention. An Automate deployment can do real damage before anyone notices, using the same model that was fine in the chat window. The shape does more to determine risk than the model inside it does. And the shape is a choice someone in your org has already made, whether they know it or not.

What to ask next time

Next time someone says "we're using AI for that," ask which shape. That one question answers most of the others. What's it costing us? Who catches it when it's wrong? How do we recover?

For now, forget the product names. Ask where you are in the loop.

Get in touch

Sizing up an AI deployment? We help teams pick the right shape for the work and build the review loop that goes with it. Get in touch.

A fifth shape is already forming at the edge: agents with job titles, persistent memory, and standing responsibilities. A post for another day. Product references in the widget are current as of April 2026.