One Call Is a Lookup. A Job Is a Chain.
Three weeks after you ship an automation, the message lands: "It stopped working."
You have screenshots. You have a chat log where the agent declared the job done. What you don't have is a record the client can open, read, and verify without you in the room. That gap — not the bug — is the real failure. And it's not fixed by better screenshots. It's fixed by changing the shape of the work itself.
The argument is simple: a single call is a lookup. A job is a chain. Most agent demos, including plenty of polished ones, only ever demonstrate the lookup. The moment you're accountable to someone else, the lookup stops being enough.

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: dev.to
The one-shot trap
Almost every agent example ever published teaches the same unit of work: fetch a price, run a search, check a prompt, return a string. One call, one result, demo over. It's clean, it's fast, and it's almost entirely useless as evidence.
A single call produces a single receipt. That receipt says "I asked, something answered." It does not say what was asked, what was assumed, what was tried and discarded, what the inputs were, or why the output should be trusted. Hand that to a client and you've handed them a rumor with a timestamp.
The source article makes the scale problem concrete: today, 234 callers ran 1,452 calls through Zambo. Six of those jobs ended in a handover. Read that ratio again. Roughly 1,450 discrete operations produced six artifacts a human could actually take responsibility for. That is not a throughput problem. It's a shape problem. The system was optimized for calls — the countable, demo-friendly unit — and almost none of that activity ever became a job someone could stand behind.
What makes something a job
A job has three properties a lookup doesn't:
- A chain. It has ordered steps with named inputs and outputs, so you can point at step 4 and say what it received and what it produced. The chain is the audit trail; the audit trail is the product.
- A defensible state. It knows what "done" means before it starts, and it can show which conditions were checked. "The agent said done" is a claim. "Here are the five checks that passed and the one that was waived" is a handover.
- A handover artifact. A document, a report, a diff, a signed ledger — something the client can verify without you in the room. If verification requires your presence, you haven't delivered a job. You've delivered a dependency.
The last point is the one most teams skip, and it's the one that decides whether you get the "it stopped working" message or a support ticket with context. A screenshot is a claim about the past. A chain is a record of it.
Counterpoint: chains are not free
Here's the honest pushback, because the "everything must be a chain" take is wrong in at least three ways.
Some things are genuinely lookups. Fetching a price, resolving a timestamp, checking whether a file exists — these don't need a five-step orchestration and a signed ledger. Wrapping a trivial lookup in a chain adds latency, cost, and failure surface for zero accountability gain. The skill is classifying work correctly, not chaining everything.
Chains multiply failure modes. Every added step is another place to time out, another schema to validate, another retry policy to get wrong. A three-step chain has more ways to fail than a call, and a poorly instrumented chain fails quieter — you get a plausible-looking output assembled from a step that silently degraded. The counter to this is not fewer chains; it's per-step observability, which is real engineering work.
Handover artifacts can become theater. It's easy to generate a beautiful PDF that nobody reads and that attests to nothing. A receipt is only worth what it lets someone check. If the artifact can't be independently verified — if it's just a summary of what your own system says it did — you've reinvented the screenshot with more steps.
So the claim isn't "chain everything." It's narrower and more useful: if someone other than you has to trust the result, the result needs a chain. Lookups are for you. Chains are for handovers.
The number that actually matters
Stop measuring calls. Calls measure activity, and activity is cheap — 1,452 of them in a day is not a flex if only six became something a human could own.
Measure handover rate: the fraction of executed work that produced a verifiable artifact. That's the metric that predicts whether you get a renewal or a "it stopped working." A system with a 4% handover rate is a very busy system that is failing at its actual job. A system with a 60% handover rate and a tenth of the call volume is a business.
The 6-out-of-1,452 figure is the whole article in one statistic. The calls were never the work. They were the noise the work was hiding in.

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: dev.to
30-day action plan
Days 1–5 — Classify. Take every automation you currently run and label it lookup or job. The test: does anyone outside your team need to trust the output? If yes, it's a job, and it owes a handover. Be ruthless; most "jobs" will turn out to be lookups wearing a job's clothes.
Days 6–12 — Define the receipt. For each real job, write the handover artifact before writing the chain. What must it contain for a client to verify it alone? Inputs, steps taken, checks passed, checks waived, timestamp, and the identity of whatever executed each step. If you can't specify it on one page, the job is under-defined.
Days 13–20 — Build one chain end to end. Pick the highest-stakes job and convert it from a single call to an explicit chain with named steps and per-step logging. Don't build a framework. Build one chain, instrument it, and make the handover artifact generate from the logs rather than from prose. One working chain beats a platform sketch.
Days 21–25 — Break it deliberately. Kill a mid-chain step and confirm the artifact says so. Feed it bad input and confirm it refuses rather than proceeding. The point of the chain is that failure is legible. If a failure looks like success, you've built a screenshot with extra latency.
Days 26–30 — Instrument the real metric. Ship handover rate to a dashboard. Track calls, jobs, and handovers side by side, and watch the gap. Then run the client test: can someone verify a completed job without messaging you? If they still have to ask, the chain isn't done.
The takeaway
The industry has spent two years getting very good at demos and calling it automation. Demos are lookups. They're impressive for ninety seconds and unfalsifiable forever after. The durable version of this work is a chain that produces something a stranger can check — because the moment money, liability, or a client relationship is involved, "the agent said it was done" is not a deliverable. It's the setup for the message you get three weeks later.
One call is a lookup. A job is a chain. Build the chain, and hand over the receipt.
Sources
- Rambo Zambo, "One Call Is a Lookup. A Job Is a Chain," DEV Community — https://dev.to/rambozambo/one-call-is-a-lookup-a-job-is-a-chain-3d0i
- Operational figures (234 callers, 1,452 calls, six job handovers) as reported in the source article.



