Most first AI agent projects die before anyone builds anything. They die at the selection step. In June 2025, Gartner predicted that over 40% of agentic AI projects will be canceled by the end of 2027, naming escalating costs, unclear business value, and inadequate risk controls as the killers (Gartner, 2025). "Unclear business value" is a selection failure. It happened months before launch, on the day someone picked the wrong workflow.
So the question of what to automate first with AI isn't a warm-up question. It's the whole game. You've got the mandate (or you're the founder doing twelve jobs), a mental list of 40 candidate tasks, and no defensible way to rank them. Pick the flashy one, and you'll spend month three explaining a stalled demo.
This post gives you a three-part test you can run against your task list this afternoon. It comes from how Vercel's CEO tells operators to start, and it ends with one artifact you produce before anything gets built.
The short version: Pick your first agent workflow with three filters: it's toil you'd gladly delete, it has a system to it, and you can write down its scale before you build. Vercel CEO Guillermo Rauch prescribes exactly this. In 2025, Gartner predicted over 40% of agentic AI projects will be canceled by end of 2027, mostly for unclear business value (Gartner, 2025). The scale write-down is what makes yours provable.
Why does your first AI agent matter so much?
Because adoption is solved and value is not. In November 2025, McKinsey's State of AI survey of 1,993 organizations found 88% now use AI regularly in at least one function, yet only about 6% qualify as high performers and just 39% attribute any EBIT impact to it (McKinsey, "The State of AI", 2025). Everyone's using it. Few can prove it moved a number. Your first pick decides which group you join.
The mechanics are social, not technical. A failed first project doesn't just waste a build; it poisons the room. When you ask for a budget in month three, someone remembers the agent who confidently did something dumb at scale. A boring win compounds instead: quiet, provable, repeatable.
Which is why the common instinct is exactly backwards. Automating your most visible task first feels like the fastest win. It's usually the fastest way to kill internal confidence, because visible tasks have visible failures and usually need judgment at every step. We've watched operators learn this the expensive way, and it rhymes with why the demo worked and the rollout died.
The data backs the caution. In September 2025, BCG surveyed 1,250 senior executives and found that only 5% of companies are built to generate AI value at scale, while 60% see minimal gains (BCG, 2025). And in May 2025, IBM's study of 2,000 CEOs found only 25% of AI initiatives had delivered their expected ROI, with just 16% scaled enterprise-wide (IBM IBV, 2025). These firms didn't fail at model selection. They failed at work selection and follow-through.
What did Vercel's CEO actually say about picking a first task?
Three clauses, and each one is a filter. On the Agent Native podcast in August 2026, Guillermo Rauch, CEO of Vercel, told operators to "pick a toil task of your business that has a system to it... it's something that if you could automate it away you'd absolutely automate it away and write down the scale of that task". Vercel runs an internal agent that almost 1,000 employees use, so this is practiced advice, not a keynote line.
Unpack the sentence, and you get the whole selection framework. Toil: work you'd delete without regret. System: work with repeatable steps. Scale: work whose volume you can write down. That last clause is the one nobody else says out loud, and we'll spend a full section on it.
His own example is Vercel's product changelog, which an internal agent cut down to a single Slack thread. We tore down that changelog workflow end-to-end in a separate post, so I won't repeat it here. This post is about the step before that one: choosing.
Filter 1: Is it a tool you would delete without regret?
Toil hides inside measured noise. In June 2025, Microsoft's Work Trend Index found workers were interrupted every two minutes during core hours, absorbing 117 emails and 153 Teams messages on an average weekday (Microsoft, "Breaking Down the Infinite Workday", 2025). Somewhere in that blizzard sits your candidate: the recurring context-assembly nobody chose as a job. Across a full 24-hour span, the same report counts 275 interruptions a day.
The test is Rauch's phrasing, taken literally. If this task vanished tomorrow, would you mourn it or celebrate? Assembling the same renewal summary every week: celebrate. Talking to the customer about that renewal: mourn. That line matters, because toil and judgment often live inside the same workflow, and only one of them belongs to an agent.
Our position at PromptMetrics is blunt on this. Automate the friction, the repetition, the context-assembly. Keep the judgment. A coding agent that removes thinking from your team is not progress; one that removes the 40 minutes of tab-switching before the thinking starts is.
One refinement from Rauch that surprised me: toil isn't always low-value work. "Maybe it's like quote unquote a secret sauce of something you do really well, but takes a lot of time, and you want to do more of it. And so start with that skill, connect you to a communication channel". The best first candidate is sometimes systematized excellence starving for volume. You're not deleting the task. You're deleting the bottleneck on how often it happens.
Filter 2: It has a system to it
Here's the operational definition: a task has a system to it when one human can write its steps, inputs, and escalation points on a single page. If nobody on your team can produce that page, an agent can't run the task either. And that same page, once written, becomes the skill file the agent runs on. Plain Markdown you own, not a proprietary layer you rent. Worth remembering when you're shopping: in the same June 2025 release, Gartner estimated that only about 130 of the thousands of vendors selling "agentic AI" are legitimate, with the rest rebranding existing products (Gartner, 2025).
Signals that the system is real: a clear trigger (a Slack post, a closed-won deal, a Monday morning), known inputs, decisions you can state as if-then rules, and errors you can recover from. Credit where due, most decent selection guides converge on these signals. The shape of the work decides what an agent can hold, and a one-page system is the shape that fits.
What the guides skip is that the system test doubles as governance design. The exact step where the one-pager says "a person decides" is the exact step where the approval gate belongs. Draft-then-review, never unattended writes. We don't build autonomous agents; every write action waits for a human approval inside the tool. Write the system down, and you've drawn the gate's location for free. (Full disclosure: our replayable approval-object architecture, where every gate decision is stored with the exact pending change, is designed at PromptMetrics, not yet built. The one-page system plus a Slack approval is buildable today.)
Can't produce the page yet? That's not a rejection. It's a to-do. Some of the best first workflows only needed a week of "write down what we actually do" before they qualified.
Filter 3: Can you write down the scale of it?
This is the filter every competing guide skips, and the one Rauch names explicitly: "write down the scale of that task". How many times a week does it run? How many minutes per pass? How many people touch it, and how many handoffs? Four numbers on a sticky note. That write-down has a second identity: it's a baseline.
What does it look like in practice? Three illustrative examples from Acme Corp, our placeholder company, with the arithmetic shown:
A RevOps weekly pipeline-hygiene pass: 6 passes a week x 35 minutes x 2 people = 7 hours a week.
A CS renewal-summary assembly: 20 renewals a month x 25 minutes = about 8.3 hours a month.
A founder's Monday reporting grind: 1 pass a week x 90 minutes = 6 hours a month, all of it Monday morning.
Illustrative numbers, not client results. Yours will differ, which is exactly why you write yours down.
Now connect this to the McKinsey number from earlier: in 2025, only 39% of AI adopters could attribute any EBIT impact to it (McKinsey, 2025). I'd bet most of the other 61% have impact stories. What they don't have is a before-number, so the story stays an anecdote. Nobody can show an impact they have never measured. The scale write-down is the discipline everyone skips, and skipping it is what turns a working agent into an unprovable one. It's not a proprietary method. It's just the step between "pick" and "build" that never gets its own meeting.
The same McKinsey survey keeps the ambition honest: 23% of organizations report scaling agentic AI somewhere, but no more than 10% are scaling agents in any individual function (same source). Early days, everywhere. A baseline is how you'll know if your first workflow actually worked, instead of asking the room how it felt.
How do you run the toil test this week?
An afternoon, one list, five steps. Remember the stakes: Gartner's 2025 prediction puts over 40% of agentic AI projects in the bin by the end of 2027 (Gartner, 2025). The five steps below are how you stay out of that cohort:
List every task you touched twice last week that made you sigh. Aim for 20 to 40; don't filter yet.
Strike anything that needs judgment at every step. Judgment at one step is fine (that's where the gate goes). Judgment everywhere means it's your job, not the agent's.
Strike anything you can't write on one page. Or park it until someone can.
For the survivors, write down the scale: frequency, minutes per pass, people, handoffs.
Pick the largest scale with the lowest stakes. One task. Not three.
What should you refuse to pick, even if it scores well? Anything customer-facing on day one. Anything with irreversible writes (mass deletes, payments, contract sends). And the visible flashy thing your exec sponsor keeps mentioning; park it for workflow number three, once trust exists. The one-sentence test still rules: if you can't name the broken workflow in a sentence, you haven't found it yet.
This next part is the actual intake filter we run in PromptMetrics Discovery calls, published as a worksheet. Score each surviving task, one point per yes:
markdown
# The Toil Test Worksheet (score each task, 1 point per yes)
Task: ______________ Named in one sentence? If no, stop here.
1. Ran 4+ times in the last month? [ ]
2. You'd delete it tomorrow without regret? [ ]
3. Someone can write the steps on one page, today? [ ]
4. Every decision point statable as an if-then rule? [ ]
5. Errors recoverable (no irreversible writes)? [ ]
6. Internal-only (no customer sees a mistake)? [ ]
7. Scale written down (freq x minutes x people)? [ ]
8. Lives in a channel your team already opens daily? [ ]
7-8: build it. 5-6: fix the gaps first, usually the
one-pager or the baseline. Below 5: wrong first task.Eight questions, and question 7 is the one that fails most often. It's also the cheapest to fix: a week of counting alongside normal work, no new software.
Field note from our own rebuild. Two tasks from my list went head to head. Publishing-pipeline assembly (gather drafts, check links, stage, schedule) scored 8: ran constantly, fully systematic, scale written down at roughly 5 hours a week. Partner-outreach drafting scored 4, but I built a version of it first anyway, because it felt more valuable. It drifted within two weeks; every message needed judgment, and no two passes matched, so there was no system page to correct it against. I threw it away and built the boring one. The boring one still runs. The failed pick taught me more than the win: scoring 4 and building anyway is how you become Gartner's statistic.
Frequently asked questions
What should you automate first with AI?
A recurring internal task that passes three filters: it's toil you'd delete without regret, it has a system a human can write on one page, and you can write down its scale before building. Vercel CEO Guillermo Rauch prescribes exactly these filters (Agent Native podcast, 2026), and the scale write-down doubles as your baseline.
Why do most first AI agent projects fail?
Selection, mostly. In 2025, Gartner predicted that over 40% of agentic AI projects would be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls (Gartner, 2025). Unclear value traces back to the pick: no baseline, no provable result.
Should your first AI agent workflow be customer-facing?
No. Keep the first workflow internal, with recoverable errors and a human approval on every write action. In May 2025, IBM found that only 25% of AI initiatives delivered their expected ROI (IBM IBV, 2025). Internal, gated workflows are where those odds improve, because failures are cheap and reversible.
How long should choosing a first agent task take?
An afternoon for the toil test, plus up to a week counting the baseline alongside normal work. If the task passes all three filters, a first-governed skill is a one-to-two-week fixed-scope build, not a quarter-long program. Compare that to the 2027 cancellation wave Gartner projects for projects that skipped this step (Gartner, 2025).
What to automate first, one last time
Boring beats flashy. The visible task is the trap; the sighed-at task is the win.
Systematic beats creative. One page of steps, or it waits.
Measured beats vibes. Write down the scale before you build. It's your baseline.
One task. Not three.
One more honest thing. A good pick doesn't guarantee a good build. Governance, the gate, and the month-three maintenance habits still decide the outcome, and we've written before about where those go wrong. We also say plainly what's designed versus built at our own shop, because you should demand the same from anyone you hire. If you're comparing outside help, here's how to evaluate an implementation partner without getting demo-washed.
