Georgia State University — J. Mack Robinson College of Business PATH — Pathways for AI Training & Hiring CIS 4394 Agentic AI  ·  Fall 2026  ·  Dr. Xinyu Fu
02 · From notebook to production

Shipping an agent.

Two halves, one lesson. First: computer-use agents — the most general thing an agent can do, and the least reliable, according to the benchmarks built to measure it. Then: what actually changes when a working notebook becomes something that runs unattended, costs money per run, and has to be turned off at 2 a.m. by someone who did not write it.

The general case

Agents that use a computer like a person

Tool calling — Week 5
place_order(sku="8812", qty=4) -> {"order_id": "A-99213", "total": 54.20} Precise. Typed. Fails loudly. Limited to what somebody exposed as an API.

A clean contract with the world. If the vendor never built an API, the agent cannot reach them.

Computer use
screenshot() -> [an image of a screen] click(x=612, y=344) type("4") screenshot() -> did that work? Universal. Untyped. Fails quietly. Works with any software a person can operate.

The agent perceives pixels and acts with a mouse and keyboard — no API required, and no schema to catch a mistake either.

Why anyone wants this. Most enterprise software is not going to grow an agent-friendly API on your schedule. A computer-use agent is the universal adapter: if a person can do it in a browser or a desktop app, the agent can attempt it. That generality is exactly where the reliability goes. Anthropic shipped a computer-use capability for Claude in 2024; OpenAI followed with Operator in 2025. Both arrived explicitly framed as early, supervised, and limited — read them as previews of a capability, not as finished products.
Watch

See it move

Claude — computer use for automating operations

Anthropic's own short demo: the model looking at a screen, moving a cursor, filling fields. About two minutes, and worth watching for the rhythm — look at how much of the run is the agent checking whether its last action worked.

Source: Anthropic (official channel).

Operator — OpenAI's first computer-using agent

A longer third-party walkthrough (Developers Digest, roughly 16 minutes) of OpenAI's Operator browsing and acting on live sites. Watch it for the failure texture: hesitation, re-reads, and the places a human has to step in.

Third-party review, not an official OpenAI channel — useful as a demonstration, not as documentation.

The humbling part

What the benchmarks say

Two research benchmarks put agents in real computer environments and score whether the task actually got done. Both are worth knowing by name, because both are the standard reply to “we'll just let it run.”

Desktop tasks

OSWorld (Xie et al., 2024)

369 real tasks in real operating-system environments, executed and verified rather than graded on plausible-looking output. As reported in the paper at publication: humans completed above roughly 72% of the tasks, while the best model setup the authors evaluated finished around 12%.

Humans~72%+
Best agent~12%

arXiv:2404.07972 ↗

Web tasks

WebArena (Zhou et al., 2023)

812 long-horizon tasks in a realistic, self-hosted web environment — shopping, a forum, a code host, a CMS — again scored on whether the end state is correct. As reported at publication: a GPT-4-based agent succeeded on roughly 14% of the tasks.

Agent~14%
Tasks812

arXiv:2307.13854 ↗

Read these as dated, and say so out loud. Each figure describes the systems that existed when that paper was published — 2023 for WebArena, 2024 for OSWorld — and reported scores on both benchmarks have moved since. Do not carry these percentages into a meeting in 2026 as current facts; go to the papers and their leaderboards, and quote what is there on the day you speak. What is durable is the shape of the finding: long, multi-step tasks in messy real environments are far harder for agents than short, bounded ones, because errors compound across steps — the same compounding-reliability argument from Week 8.
Interactive · the shipping decision

Match autonomy to reliability × reversibility

The benchmarks do not say “never ship.” They say the safe envelope is narrower than the demo suggests. Pick the two properties of your task and see where it lands.

1 · If the agent gets it wrong, what does it cost?
2 · Who is watching?
Verdict

Choose one from each list

The rule underneath this widget is a single sentence worth memorizing: autonomy is earned by reliability and bounded by reversibility. An unreliable agent can still be shipped — on reversible work, with someone reviewing. A reliable one still should not run unattended on irreversible work.

The other half

What changes from notebook to production

One user — youThousands of runs, concurrent, at hours nobody chose
You are watching every runNobody is watching — unless you built something that watches
The happy path, on inputs you pickedAdversarial and weird inputs, including deliberate ones
Cost is invisible — a free tier, a few callsCost is metered and shows up on somebody's budget line
"It worked"A commitment: how often, how fast, and what happens when it does not
No logs beyond your terminalAn audit trail somebody else can read months later
None of these are AI problems. They are the ordinary operations problems of running software, arriving all at once because the demo skipped them. That is good news: this is the part of agent work with fifty years of practice behind it.
Money

What does one run cost?

Not “what does the model cost per million tokens” — that is a price, not a cost. The number a manager needs is the cost of one completed task, which is a different and larger thing.

cost per completed task ≈ tokens per step × price per token × steps per run × attempts per completed task
Why agents cost more than they look like they should

Every step re-sends the conversation so far. Step 6 pays for steps 1 through 5 all over again, so tokens per run grow faster than steps do — the reason a multi-step agent can cost many times a single call for the same question. Add failed attempts, and the true denominator is completed tasks, not runs.

The honest way to get this number: instrument a real run and read it off, then multiply by expected volume. Every estimate assembled from published prices and guessed step counts is a story; the meter is the fact.

Four levers, in the order to pull them
  1. Cap the steps. The single most effective lever, because it bounds the worst case rather than shaving the average. A run that cannot exceed N steps cannot produce a surprise invoice.
  2. Right-size the model. Not every step needs the strongest model. Classification, extraction and routing steps are often the cheap model's job; keep the expensive one for the hard decision.
  3. Cut the round-trips. Every tool call is a step, and every step re-pays for the context. Batch what can be batched; combine two tools a run always calls together.
  4. Cache what repeats. Stable instructions, schemas, and reference material get re-sent every step by default.
The break-even question. The comparison is never “agent vs zero.” It is agent vs whatever the work costs today: the person doing it, at their fully-loaded rate, at the current volume. Put the agent's fully-loaded cost on the other side — tokens plus infrastructure plus the human minutes spent reviewing approvals and cleaning up failures. If you cannot state both numbers, you do not yet have a business case; you have a demo.
Time

The latency budget

Steps are round-trips

A multi-step agent is a sequence of network calls to a large model, each one waiting on the last. What feels instant in a notebook becomes tens of seconds in a product, and the user has no way to tell “thinking” from “broken.” Latency is a product decision before it is an engineering one: stream partial progress, show which step it is on, and pick a smaller model for the steps that do not need the big one.

Rate limits are a real constraint

Your provider caps requests and tokens per minute. One agent at a time never notices; a hundred concurrent runs discover it at once — as errors, in production, usually on the busiest day. Handle it deliberately: a queue, exponential backoff with jitter, and a concurrency limit you chose rather than one the provider imposes on you mid-run.

The hard one

Retries, and why idempotency matters more than anything on this page

Networks fail halfway. That is not an edge case; it is the normal condition of distributed systems. The question is only what your code does about it.

# the bug that becomes a refund try: place_order(sku, qty) # times out except Timeout: place_order(sku, qty) # ...and now there are two # the fix: the caller decides the identity key = f"restock-{sku}-{qty}-{week_of(now)}" place_order(sku, qty, idempotency_key=key) # retry with the SAME key -> the vendor returns the # original order instead of creating a second one
What an idempotency key is

A caller-generated identifier for this intended action, sent with the request. If the same key arrives twice, the server returns the original result rather than performing the action again. It has to be generated before the first attempt and reused on every retry — a key generated inside the retry loop is a new key each time, which is the same bug wearing a hat.

Where agents make this worse

A retrying agent is not a retrying HTTP client. It may re-plan, decide the order “did not go through,” and place a subtly different one — different quantity, different vendor — which no idempotency key will catch, because it is a genuinely new request. So the loop needs the other half too: read back the state of the world before acting again. Check for an existing order before creating one.

Operations

Watch it, roll it back, turn it off

Monitoring & alerting

Log every run as a trace, and alert on the signals that mean something is wrong before a customer notices: cap-hits (an agent that keeps hitting the step limit is failing, not economizing), spend approaching the monthly limit, retry rate, approval-rejection rate, and success rate against your eval suite. Rising rejections at the gate is the most useful early warning you will get — humans are telling you the agent's judgment has drifted.

Rollback

A prompt change is a deploy. So is a model version change, and that one can happen without you touching anything. Keep prompts, tool definitions and model versions pinned and versioned, re-run the eval suite before promoting, and be able to return to the previous version in minutes. "Roll back the prompt" should be as ordinary as rolling back code.

The kill switch and the human

One flag that stops new runs immediately, reachable by someone who is not you, documented where they will look at 2 a.m. Then name the on-call person, and tell them what to do first: stop new runs, freeze the spend, pull the trace, notify whoever is affected. An unowned agent in production is an incident waiting for a volunteer.

Deployment checklist

Before this agent runs unattended

Business framing

The manager's four questions

If you can answer these four in a meeting without hedging, you are ready to deploy. If you cannot, the missing answer is your next task.

1 · What does a run cost?

A measured number per completed task, not per API call, with the arithmetic visible: tokens per step, steps per run, attempts per completion, plus the human review minutes. Then the comparison that makes it mean something — the fully-loaded cost of doing this work the way it is done today, at current volume. A good answer also names the largest lever and what it would save. A weak answer quotes a price per million tokens, which is not a cost and not per task.

2 · What happens when it fails?

Failure is a designed path, not a surprise. Name the modes — a tool errors, the model loops, the cap fires, a purchase half-completes — and say what the system does for each: retry with the same idempotency key, fall back to a simpler path, or stop and hand the task to a human with the trace attached. Say who finds out and how fast. The honest version includes the failure rate you actually measured and the tax it implies in rework.

3 · Who is accountable?

A person's name. Not "the AI team," not "the vendor." That person owns the eval numbers, the spend limits, the approval policy and the on-call rotation. Underneath the name sits the machinery that makes accountability possible: an audit trail linking each action to the authorization that permitted it, so "who decided this" has an answer that does not depend on memory. Accountability that cannot be evidenced is just blame waiting to be assigned.

4 · How do we turn it off?

One switch, documented, reachable by someone who did not build it, tested at least once. Say what it does precisely: stops new runs, and — separately — whether in-flight runs are drained or killed, because those need different answers when money is moving. Then the sequence after the switch: freeze spend, pull traces, assess what already executed, notify the affected parties, and roll back to the last known-good version. Practice this before you need it; the first time should not be during the incident.
Concept check

Three questions before you move on

← Previous01 · Agents that buy