An Agent Now Costs About What an Offshore Hour Costs, and the Agent Keeps Getting Cheaper

Think about the self-checkout lanes at a big grocery store. Six machines stand in a row, and one employee stands at a small podium watching all of them. Most of the time the employee does nothing you can see. Then a light turns red over lane four, because the scale didn't believe a bag of limes. The employee walks over, taps in a code, and walks back.

That store used to pay six cashiers to run six lanes. Now it pays for six machines and one person, and that person's whole job is the red light. When the arrangement works, the store saves money and you get out faster. It doesn't always work. In March 2024 Dollar General took self-checkout out of about 300 stores to cut its losses from theft and scanning mistakes. The machines were cheap, and what slipped past them wasn't.

I've been thinking about those lanes because the same arrangement is arriving in a much bigger business, which is the routine software and back-office work that companies send offshore. The machine turns out to be the small part of the bill. The person at the podium is the large part.

The claim

For thirty years companies have sent routine work to India, the Philippines and elsewhere for one reason: an hour of labor costs less there. For some of that work, an AI agent with a person checking it now costs about the same as the offshore hour, or less. Once the two costs cross, I don't think they cross back. Offshore wages rise a few percent a year, and the agent's side of the bill keeps falling.

The name going around for this is AI shoring: one more sourcing choice next to offshoring, nearshoring and onshoring. I built a calculator under that name in March and believed I'd coined it. I hadn't. Samuel Sutcliffe used it in January 2025 for banking process teams. Mark O'Neill at Gartner described it in April 2025 as one senior developer with AI tools in place of an offshore team, and Gartner published his note on it this January. A New York company has a US trademark application pending on the phrase. HFS Research calls the same shift services-as-software, Reply calls it silicon shoring, and LeadDev calls it agent-shoring.

So the name belongs to other people. What I haven't seen any of them publish is the arithmetic, with the person who checks the agent counted in. This post is the arithmetic.

Key point: Compare an agent with an offshore hire per finished unit of work, and count the person who checks the agent. On that basis support chat and invoices have already crossed, and routine code tickets are crossing now.

Count the finished unit, not the hour

An hourly rate tells you very little, because what you're buying is a resolved chat, a processed invoice or a fixed bug. So the model prices one finished unit on each side.

The offshore hire needs three numbers: the rate the vendor bills per hour, how many units a person finishes in an hour, and what you spend managing the vendor. ISG puts that last one at 8 percent of the contract when it's done well and 15 percent commonly. I use 15.

The agent needs three numbers too: what the machine costs per attempt, what it costs for a person to check that attempt, and what share of attempts succeed. The attempts that fail go back to a person, so they cost you the human price on top.

human cost per unit   C_h = (rate / units per hour) x (1 + overhead)
agent cost per unit   C_a = machine + checking + (1 - success rate) x C_h
 
the agent wins when   machine + checking  <  success rate x C_h
 
threshold rate        w*  = units per hour x (machine + checking)
                            / (success rate x (1 + overhead))
 
payback volume        N*  = setup cost / (success rate x C_h - machine - checking)

The threshold rate is the number to watch. If your vendor bills more than that per hour, the offshore hour loses on cost. The last line explains why small jobs stay with people: an agent has a setup cost, and it takes volume to earn that back.

Three kinds of work, three different answers

Support chat has crossed. Chat support from India or the Philippines bills at about $10.50 an hour, by the rethinkCX cost index for May 2026. At 11 minutes a chat, which is what Klarna's human agents averaged, and ordinary occupancy, a person finishes 4.5 chats an hour. That is $2.68 a chat with overhead. Intercom's Fin lists $0.99 per resolved chat and charges nothing when it fails. Intercom says 76 percent get resolved, and third parties report nearer 50. Either way the threshold works out to $3.87 an hour. The worker takes home roughly 30 percent of the billed rate, or $2.40 to $5.20 an hour. The agent's list price already matches the worker's pay, never mind the vendor's rate. And $0.99 is a price. Anthropic's own worked example puts the model cost of a support ticket at about a third of a cent.

Invoices have crossed, if you have the volume. Outsourced invoice processing sells for $1.50 to $5.00 an invoice, by vendors' own figures. AWS charges a cent a page to read an expense document, and a language model adds a fraction of a cent. About 23 percent of invoices are exceptions that need a person. That comes to $0.77 against $3.25. The machine's share is two cents, and the rest is people handling exceptions. With an $18,000-a-year tool, payback comes at about 7,300 invoices a year. Below that, keep the people.

Routine code tickets are crossing now. This one rests on assumptions, so here they are: a junior offshore developer at $25 an hour, and four hours for a routine ticket, which makes $115 with overhead. Vendor rate guides put junior developers in Asia at $24 to $31. The agent costs about $5 an attempt; published figures run from $1 to $13. A senior engineer spends 30 minutes checking each attempt, and at $114 an hour that's $57. Independent studies find 43 to 83 percent of agent pull requests get merged, depending on the tool. The answer is a tie: $115 for the person, and $82 to $128 for the agent.

Move the sliders and put in your own numbers.

Most of the agent's bill is the person at the podium

Look at the code ticket again. The machine is $5 and the checking is $57. More than ninety percent of what each attempt costs is the senior person who reviews it. Token prices could fall to zero tomorrow and the ticket would cost almost the same.

The field data says the same thing. Faros AI found that teams using AI merged 98 percent more pull requests and spent 91 percent longer reviewing them. In a 2026 study of 802 developers whose company told them to double their output, they did double it. Each reviewer's load doubled too, and automated review had to overtake human review before it held together.

Goldratt would recognize this. Every system has one constraint. When agents make doing the work cheap, the constraint moves to checking it, and money spent anywhere else is wasted. (Our bike shop simulator lets you watch a constraint move.) So the way to lower the threshold is to make checking cheaper: better tests, narrower tickets, automated review, and senior people who know the codebase.

Key point: If you want to know whether a piece of work is ready for agents, don't ask what the model costs. Ask how long it takes a person to know the output is right.

After the lines cross

The two sides then move in opposite directions.

• The offshore hour creeps up. Indian IT salaries rise 6.6 to 7 percent a year, and the rupee has lost about 3 percent a year against the dollar, so in dollars the hour rises 3 to 4 percent a year. Right now clients are also forcing one-time cuts of 25 to 30 percent. That buys the rate card a few years. It doesn't change the slope.
• The machine gets cheaper for a fixed job. The price of a fixed level of model capability falls 5 to 10 times a year. Frontier agent tasks haven't become cheaper, because newer agents burn far more tokens on harder problems. A routine ticket needs the same skill next year as this year, so the first number is the one that applies.
• Success rates rise and checking shrinks. These two move the threshold most. If the merge rate for routine tickets goes from 60 to 85 percent over five years, and checking falls from 30 minutes to 10, the threshold drops from about $22 an hour to about $5. That is a scenario you can change in the chart above. I'm not offering it as a forecast.

Other kinds of engineering have been through this. The mechanical cotton picker broke even with hand labor around 1948, when the picking wage passed $2.50 per hundred pounds. Machines picked almost none of the American crop that year and 96 percent of it twenty years later. William Nordhaus found the cost of a computation fell 37 percent a year from 1945 to 1980. Once a machine matches the wage, the wage keeps rising slowly and the machine keeps getting cheaper fast.

The same history carries a warning about reading this as the end of jobs. James Bessen found that textile, steel and auto employment grew for decades alongside automation, because cheaper output sold in much larger volume. Jobs fell only when demand stopped growing. The US Bureau of Labor Statistics still projects developer jobs up about 16 percent from 2024 to 2034.

Cheap versus checked

The contradiction is this: agents make the work cheap, and cheap work that nobody checks gets expensive fast. Quimby's matrix shows four ways to answer it.

Most of the industry is moving from Q1, the Rate Card, to Q3, the Faster Pyramid. It's the comfortable move, because the team and the contract stay the same. The savings go back to the client as price cuts, and the work is still sold by the hour.

Q2, the Empty Lane, is the tempting mistake. It's the store that installs the machines and sends the attendant home. Klarna said in 2024 that its assistant did the work of 700 outsourced agents, and said in 2025 that quality had dropped and it was hiring people again.

Q4, AI Shoring, puts the agents on the volume and spends part of the savings on the podium. The clearest account I've found comes from PatientPoint's former CIO, who told InformationWeek that 10 to 15 people with AI now do what 40 to 50 offshore developers, testers and analysts did. The small senior team is both of the model's hidden costs: they're the setup cost, and they're the checking cost.

Where this argument is weak

I'd rather you hear the weak spots from me.

• The productivity gain is smaller than the sales pitch. Careful studies put a senior team's gain on ordinary company code at 20 to 50 percent. Doubling is the best documented team result. METR's 2025 trial found experienced developers 19 percent slower with AI while believing they were faster. "A team three to five times smaller" isn't supported yet.
• Offshore firms use the same tools. They're cutting prices and they're still here. India's company-owned centers grew to 2.36 million people this year. A lot of the work is changing owners without changing countries.
• I can't name a large company that has said on the record it ended an offshore IT contract because of AI. The pressure shows up in prices and headcount. The top five Indian firms shrank by about 7,400 people in fiscal 2026 while revenue stayed roughly flat.
• Forecasts of collapse have a bad record. In July 2023 Emad Mostaque said most outsourced Indian coders would be gone in two years. Nasscom counts 5.95 million people in the sector today.
• The model leaves out the cost of a wrong answer. That cost is what sent Klarna back to hiring, and it's different for a password reset than for an insurance claim.
• The podium needs people, and the routine work used to train them. Stanford's payroll study finds employment of 22-to-25-year-olds in AI-exposed jobs down 19 percent in relative terms, mostly from hiring that never happened.

Five predictions you can check

I'll come back to these when the dates pass.

1. By the end of 2027, at least one of the large support-agent products lists a resolved conversation below $0.50. Today's list prices run $0.99 to $2.00, against a model cost of under a cent.
2. By March 2028, the five largest Indian IT firms together employ fewer people than they did in March 2026, on higher revenue.
3. By the end of 2028, most new contracts for first-line support and invoice processing are priced per finished unit. HFS found only 5 percent of customer-service buyers contracted that way in 2026.
4. By the end of 2028, independent studies find agents' pull requests for routine tickets merged 85 percent of the time or better, which puts the model's threshold for that work under $12 an hour. No offshore developer bills that little.
5. In 2030, India's technology sector still employs more than five million people. The work moves up and moves in-house. It doesn't vanish.

What I'd do with this

Go back to the lanes. The store that pulled its machines out didn't have a machine problem. It had too few people at the podium, watching too many lanes, with no good way to tell a mistake from a theft.

If you buy offshore work, I'd start where the volume is high and checking is quick, which usually means support and documents before code. I'd put a senior person at the podium before anyone's contract is cut. I'd measure two numbers every month, the share of attempts that succeed and the minutes it takes to check one, because those two set the threshold. And I'd make sure you own the instructions and the tests your agents run on. They're your know-how written down for the first time, and a vendor who holds them holds you.

The open question for us at Netrii is the last weak spot. Where do the people at the podium come from, once the routine work that trained them is done by the machines they're watching? Whoever works that out will have the scarce thing, because everyone will have the agents.

This post comes from a research session in the netrii Wisdom Library, AI Shoring, 2026-09-18, which holds the full term history, the sources, and the inputs that are assumptions. The small senior team is the subject of The Business Engineer.