AI
Let the Agent Pick the Play, Not Rewrite the Playbook
I already said the short version on X. Twice, actually.
Best AI automation rule I know: let the agent decide what to run, never how. And separately: the real unlock isn’t “agents everywhere” — it’s human control that travels with you.
This is the longer version, because those two takes are the same argument wearing different product clothes. One is about the playbook. One is about the whistle. You need both, or the agent either freelances your process or stalls in a tab you forgot open.
The playbook problem
People keep shipping demos where the model invents the entire procedure. Refunds. Onboarding. Deployments. Incident response. The agent “reasons” its way through six steps, picks tools mid-flight, and somehow that is supposed to be production.
That works until the day it doesn’t. And the day it doesn’t is usually the day money moves, data deletes, or a customer sees something that can’t be unsent.
The boring truth: a lot of the work you want an agent to touch already has a correct order. Eligibility before approval. Approval before credit. Backup before migrate. Diff before push. The model is great at noticing that a refund should happen. It is not the thing you want freelancing the eligibility check because it felt confident.
AWS made that distinction concrete on October 29. Step Functions workflows — Standard and Express — can now be exposed as tools for AI agents through Amazon Bedrock AgentCore Gateway. The agent decides when to run the workflow and what input to pass. Step Functions runs each step exactly as you defined it.
Their own example is the right one: a customer support agent starts your refund workflow, and the state machine still does eligibility, manager approval, and credit, in order, every time. The agent picks the play. It does not rewrite the playbook.
That is not a vibes take. The gateway pins start/list tools to the state machine you choose. The agent cannot swap in a different machine. IAM on the gateway role scopes which executions the agent can describe or stop. The execution history records what actually ran. You get the model’s judgment about timing without handing it the keys to invent procedure.
If you have spent any time watching agents invent tool sequences, this feels like somebody finally put the fence where the fence belongs.
What “callable as a tool” actually buys you
The useful mental model is sports, not sci-fi.
A coach does not let the quarterback redesign the play in the huddle every snap because the defense looked interesting. The quarterback reads the defense and picks from a playbook that already exists. Audibles are real. Rewriting the offense mid-drive is chaos.
Step Functions-as-tools is the audible pattern for agents:
- The workflow is the play. Same steps. Same order. Same audit trail.
- The agent is the reader. It decides whether and when, and with what input.
- Ops can still look up runs, see where something failed overnight, and go fix the broken step instead of reverse-engineering a chat log.
You can already build some of this with custom MCP servers and a pile of Lambda. The point of the October launch is that you do not have to. Existing Standard and Express workflows become tools without you writing a tool schema by hand. That matters because the teams that will actually ship agent automation are the ones that already have workflows they trust — not the ones rewriting everything as “agent-native” from scratch.
Express when you need a synchronous answer. Standard when you need history, status, and the ability to stop a run. Human-in-the-loop task tokens still exist for the steps that should wait on a person. None of that is new philosophy. It is old reliability work, finally sitting behind the same MCP surface the agent already speaks.
The control that travels
Playbooks alone are not enough.
Agents that run for minutes, hours, or overnight will stop and ask permission. That is a feature. The failure mode is not “the agent asked.” The failure mode is “the agent asked while you were at school pickup, and the run sat frozen until you got back to a laptop.”
DigitalOcean shipped the answer to that one in early November: Cuttlefish, a native iPhone app for Managed Agents. Sessions already run in cloud sandboxes that keep going when your laptop lid closes. Cuttlefish puts the person in the loop on the phone.
What it actually does, without the marketing fog:
- Live sessions stream replies, reasoning, and tool calls.
- Approvals show the full command, file path, or diff — not a summary that hides the landmine.
- Risky requests (recursive deletes, force-pushes,
sudo, curl-piped-to-shell stuff) require Face ID or a passcode. - You can steer mid-run: correct, pause, resume, stop. Messages queue while the agent is working.
- Notifications fire when a run needs you, finishes, or fails.
I care about that list for one reason: approve/deny that only lives in a desktop tab is not control. It is a hostage situation with good intentions. Control that travels with you is what makes always-on agents tolerable instead of terrifying.
Cuttlefish is in public preview. Managed Agents is in public preview. I am not asking you to bet the company on a preview app. I am asking you to notice the pattern. The industry is converging on the same shape: agents that keep working in isolated sandboxes, plus humans who can unblock them from wherever they actually are.
Permissions are the product
Cuttlefish makes this obvious because the permission policy is explicit: actions resolve to allow, ask, or deny. With default: allow and no ask rules, a session never raises an approval and runs to completion unsupervised. That is fine for a scratch sandbox. It is a landmine for anything that can touch a repo, a customer record, or a production shell.
The teams that will survive agent week are the ones that treat the policy file like part of the app. Write tools and reads can be loose. Network calls, deletes, force-pushes, and anything that spends money or sends a message stay on ask until you have receipts proving otherwise. Risky classifications with Face ID are not theater. They are the tax you pay so the agent can keep working while you live your life.
Same idea on the AWS side. Pin the state machine. Scope the IAM. Do not expose task-token operations unless you mean to. The connector can do a lot; your job is deciding how much of that surface the model gets on day one. Start narrow. Widen when the audit trail stops surprising you.
Put the two pieces together
Here is the rule as one sentence:
Let the agent pick the play. Keep the playbook in a system that cannot freestyle. Put the whistle on your phone.
Here is what that looks like in practice:
- You expose a vetted workflow — refund, deploy gate, data export, whatever — as an agent tool. The model can start it. It cannot reorder it.
- Inside that workflow, the consequential step is marked “ask.” The run pauses.
- You get a phone prompt with the actual command or diff. Face ID if it is ugly. Approve or deny with a reason.
- The workflow finishes the boring, correct steps. You have a receipt.
That is not “agent replaces ops.” That is “agent does the noticing and the orchestration, humans keep the irreversible moments, and neither of you is glued to a laptop for the privilege.”
Most of the agent discourse still oscillates between two bad poles. Pole one: the model should do everything, trust the vibes. Pole two: agents are toys until they never need a human. Both miss the product that is actually shipping. The useful systems look like tools with guardrails and approvals with legs.
What I am watching (and what I am ignoring)
I am watching anything that makes the playbook reusable — workflows, MCP connectors, permission policies that default to ask on writes. I am watching mobile or ambient approval UX that shows the real action, not a paraphrased card. I am watching audit trails that survive a chat UI redesign.
I am ignoring demos where the entire business process lives in a prompt. I am ignoring “autonomous” as a synonym for “no one looked.” I am ignoring vendor scoreboards that measure how rarely an agent asks for help. Asking is not weakness. Asking at the right boundary is the product.
If you build this stuff, start smaller than the keynote. Pick one workflow you already trust. Expose it as a tool. Put one irreversible step behind an approval you can answer from your phone. Run it until the boring path is boring. Then expand.
The models will keep getting better at picking the play. That is the easy part of the curve. The hard part was always the same: making sure the play they pick still runs the way your world requires, and making sure a human can say yes or no without rearranging their day around a stalled terminal.
Let the agent pick the play.
Do not let it rewrite the playbook.