Every industry has its own way of getting work done. Most AI advice ignores that.
I go industry by industry, rebuild one real workflow with AI agents, and publish exactly what happens — the method, the numbers, and what broke.
The question isn't "can AI speed this step up." It's which steps still need to exist at all.
Designing experiments is what I was trained to do. I point it at real work instead of papers.
Which workflow in your industry would you rebuild first?
The heaviest AI users in a company are its most junior people. Not a guess — 17 million messages.
A working paper from OpenAI, Columbia, and Wharton studied ChatGPT Enterprise use across 1,500+ organizations, through March of this year. The cleanest pattern in it is a slope: the higher you look on the org chart, the lighter the use.
Early-career workers and trainees send roughly eight to nine more messages a week than the average active user in their own firm. Managers send fewer. Executives send the fewest.
Picture a first-year associate at a law firm. Contract summaries, first passes, "what does this clause mean" — that's where the messages come from. The people closest to the work lean on it hardest.
Two groups, each holding half the picture.
The juniors are building real skill: where it helps, where it makes things up, which draft it saves them. Nobody calls this training. It just looks like doing the work.
The managers and owners decide what gets adopted, budgeted, signed off. And they are the lightest users in their own firms.
The authors flag one caveat, and it's fair: message volume measures intensity, not importance. Four good questions from an executive can outweigh forty messages. But intensity is where the learning lives — and that learning is concentrated at the bottom of the org chart.
If you're the junior one: keep a list. The task, what you asked, what it saved you. In a year, "I use AI all day" means nothing. "Here are twenty things I stopped doing by hand" starts a different conversation.
If you run the place: the pilot you're planning already ran. Ask your newest hires what they used it for this week. Twenty minutes on a Friday. Cheaper than any adoption report, and more honest.
The learning compounds at the bottom of the org chart. The decisions sit at the top. Those two groups should be talking more than they are.
Source in the reply.
@DratchCap The best line here is easy to miss: the model proposes a view and labels it as its own until you sign off. That label is the trust mechanic, not the four-analyst council. On a month-end close, one pass shows which numbers are signed and which are still the machine's guess.
@devagrawal09 On a support desk you can see this. Your best rep's rule — "check the order history before promising a refund" — is years of judgment in one line. In a prompt it's a suggestion the model may recall. Built into the workflow, it's the step that can't be skipped.
@antpalkin The self-grading is the honest part — and the easiest to misread. A card marked fully autonomous means someone already did the watching. Start every card human-led and let it earn the label: clean runs to point to, a Friday spot-check. Triage earns it fast. Client money waits.
@unicodef1wn Great list. And if you don't write code, the first one is all you need: n8n. It's visual — drag steps onto a canvas, 400+ tools already connected, no backend to build. Pick one task you repeat every week and start there. That's the whole first step.
@malpani Not sure the eight roles are the same kind of bet.
Marketing gets it wrong, you know by Friday. Procurement gets it wrong, you know when the contract executes.
Same agent either way. What differs is how long you run wrong before anyone notices.
@protosphinx A process doc records what people do. It rarely records when they stop.
That's the gap agents fall into: the steps are legible, the escalation rule lives in someone's head. One line — "quote jobs under 8 hours, owner prices the rest" — beats three pages of the happy path.
@MSFTResearch Worth noting: in a live support queue the task mutates mid-run.
A teammate replies, the customer sends a second email, the refund rule changed last week. By step 7 the agent is still solving the ticket it saw at step 1. Cheap fix: re-read state before acting.
Source, if you want the full breakdown — Google's writeup on the setup at Dream Winds Dairy, including how the daily briefing is assembled:
https://t.co/TJzACxxtiT
A daily summary is the easy half. The hard half is making it change what you do that morning.
Here's one that does, on a dairy farm.
Paul Windemuller milks 260 Holsteins in Michigan — 30 leased cows in 2014, a highly automated barn twelve years later. Three streams of data that don't talk to each other: collars on every cow, a weather station, a portal logging milk quality and shipments. His mornings went to downloading, merging, calculating, before he got anywhere near the cows.
Two decisions made the difference, and neither is about the model.
One: the interface is a folder. No API work, no scraping. CSV exports, photos of paper receipts, PDFs, invoices — dropped into a watched directory, read and merged by a multimodal model, everything staying local.
Four narrow roles sit behind it: an orchestrator for the day, ingestion agents that standardize raw files, an analysis agent for biology and weather, a reporting agent that writes it up in plain words.
Two, and this is the part almost nobody copies: he cleaned up the target the system aims at. The standard dairy measure — income over feed cost — moves with milk and feed prices, so most of its motion every morning is news about markets he doesn't run. He froze the prices at fixed historical values. What's left only moves when the farm does.
That's why the briefing is usable. It reads like this: margin down 15 cents a cow, with the causes named — 8 cents feed intake, humidity suppressed it; 4 cents somatic cell count creeping up, an early health signal; 3 cents two cows pulled into the treatment pen. Then: adjust the ventilation.
If your daily summary reads like weather commentary, look at what you asked it to track. A number you don't control produces explanations you can't act on.
Source in the reply.
Sources, if you want to read the full sentences yourself:
Alphabet Q2 2026 earnings call transcript (the 75% line in context) — https://t.co/EZOgawOsjQ
The Home Depot x Google Cloud release, with the task list quoted above — https://t.co/fMQtXPHtL7
Google's 75% made the rounds this week. The rest of the sentence didn't.
On the Q2 call: Gemini agents "autonomously address 75% of support queries, freeing them to solve our customers' most complex challenges."
The other 25% didn't disappear. It got moved to people, on purpose. That's the design, not the leftover.
Same shape at The Home Depot. Their store phone agent gets you to an answer four times faster — and the part that keeps getting dropped is: faster than what. Not a human. The phone menu it replaced.
The tasks it took over are listed right in the release: order status, product availability, store info, starting a service request, sending a link to a pre-filled cart. Five errands. Each one has a single correct answer.
I keep seeing these read as "AI replaced support." What they actually show is narrower, and more useful. Someone sat down and sorted the work: questions with one right answer, questions without. Then shipped only the first pile.
Meanwhile 80% of enterprise apps now embed an agent, and 31% of companies have one in production. Two years ago it was 33% and 9%. The gap got wider while the models got better.
That's the tell. The blocker usually isn't the model.
The version you can do on a Tuesday: pull last month's tickets, mark the ones where you could check the answer automatically. Ship that pile. Keep a visible door to a human.
@emilygsands The clearest version of this already runs in law firms. Two clients, one firm, one lawyer cleared for both. What she may open is decided by the matter she's on, not by her login. That rule is written down, matter by matter. The agent mostly has to read it.
@MSFTResearch The hard part of email and support isn't the number of steps.
It's that other people keep moving while the agent works. Clicks that change real state are the right base — the next layer is the customer who replies mid-task, or the colleague who closes the ticket at step three.
@mattpocockuk Also worth noting: the positive version leaves a trace.
"Don't promise a refund" only shows as an absence — you'd read the whole log to confirm it. "Cite the clause you're applying" produces a line someone can spot-check on Friday.
That's what holds up in a compliance review.
@emollick The ceiling usually sits in one specific spot: whoever signs off.
Drafts can double overnight; the one partner reviewing them still has the same afternoon. So the most useful first agent often points at the review step — pre-checking, flagging, citing — not at drafting.
@alliekmiller What fixed it for us: write the return address into the request itself, at handoff time. Then a missing reply is something you can query for, not something you have to happen to notice.
@alliekmiller "where are we blocked" was the one that kept lying to us.
We built two systems to surface blockers across our agents. Both died the same way: a machine can't tell who's waiting. It only sees what got written down.
Now we ask "what did we hand off that hasn't come back?"
Source, if you want the full breakdown: https://t.co/gxbIvunWGt
One June wave, self-selected sample. Directional, not gospel. Run the step-three test this week and tell me where it broke.
"Agent" became a label before it became a capability. That's why so many rollouts feel thinner than the demo.
Here's the mechanism, in plain words.
A chatbot answers a turn. You hand it context, it hands you text, and the context dies with the turn. An agent holds state across steps. It knows what it already did, what came back, what's still open, and it keeps going until the job is done or it hits a wall it can name. Same model underneath. Different machine around it.
The wrapper looks identical at step one. The difference shows up at step three, when a human has to paste the earlier output back in so the thing can continue. That paste is the tell. If it's there, the memory is you.
Plenty of work only needs the assistant. The trouble starts when you staff a wrapper like an agent: same expectations, same permissions, without the machinery underneath.
VentureBeat asked 101 enterprises in June to grade their own portfolios. 71% said a quarter or fewer of their deployed "agents" do true multi-step work. 9% said zero.
That's not companies lying. It's a word running ahead of a thing.
Which makes the upgrade path unusually clear. Give it memory across steps. Give it tools that act instead of answer. And give yourself a way to stop it mid-run. In that same survey, 27% have no real-time way to halt a run. They read about it in the logs afterward. In the workflows I run, the stop point gets written into the step before the clever parts do.
Go find step three. That's where you find out what you actually deployed.