Vertical Agents · Field Notes
The Vertical Agent Playbook: Five Principles from Building “Cursor for Slides”
Five lessons from teaching an AI agent a craft with no right answers, for the founders building vertical agents, the investors backing them, and the institutions about to deploy them at scale.
The vertical agent gold rush has a missing manual
Every founder I meet in SF in 2026 is building a vertical agent. The pitch template is identical: take a frontier model, point it at a profession's most painful workflow, become “Cursor for ___.”
The pitch is easy. The build is brutal, and the reasons it's brutal are different in every vertical. Code has a compiler. Spreadsheets have arithmetic. When an agent for Excel gets a formula wrong, the cell tells you.
And the race is no longer a startup story. Sovereign AI programs and national champions, from Abu Dhabi to Singapore, are now deploying vertical agents at institutional scale, across functions where output is judged rather than compiled. They may move faster than the incumbents: the way markets without card networks leapt straight to mobile payments, organizations without decades of workflow debt can go agent-native without a retrofit.
We picked presentations: a domain with no compiler, no unit tests, and no objective truth. A deck is “correct” when a specific human, in a specific room, is persuaded. Building Chronicle (the thing people call Cursor for Slides, backed by Accel with angels from Google, Slack, Stripe, and Atlassian) forced us to solve the vertical agent problem in its hardest mode.
What follows is the manual we wish we'd had.
Learning 1
Spend your novelty budget on the agent, not the artifact
Our first version was beautiful and wrong. We rethought the slide itself: new format, new primitives, a fresh take on what a presentation could be. Users admired it, then went back to PowerPoint.
The mistake has a name. Mark Pincus calls great products “proven, better, new”: one genuinely new thing, layered on something proven, made meaningfully better. We had stacked novelty on novelty, asking users to adopt a new way of working and a new kind of output at once, and nobody has budget for two revolutions before lunch.
Chronicle 2.0 made the opposite bet: the output stays familiar (slides that look, export, and behave like the decks your CEO already trusts), and all the novelty goes into how they get made. That version hit #4 Product of the Year on Product Hunt.
Your users will accept one unfamiliar thing. A vertical agent is already that thing. Keep the artifact, the file format, and the mental model boring. Cursor didn't invent a new programming language; Shortcut didn't replace the spreadsheet grid. The agent is the revolution. The output should be the reassurance.
Learning 2
Constrain the canvas before you unleash the model
Give a frontier model a blank canvas and freeform pixels, and it will produce something different, and differently broken, every time. Our early agents could generate a gorgeous slide 6 that had no visual relationship to slide 5.
The fix wasn't a better model. It was a smaller action space. We built a design system underneath the agent: typed layouts, spacing rules, color tokens, chart primitives. The agent stopped painting pixels and started composing within a grammar. Quality went up precisely because freedom went down.
It's why agents write better TypeScript than JavaScript: types, linters, and frameworks aren't restrictions on the model, they're rails that convert raw capability into reliability.
Before scaling your agent's intelligence, shrink its vocabulary. Define the legal moves in your domain (clauses for legal, journal entries for accounting, layouts for slides) and force the agent to play on that board. Constraints are not the cost of quality. They are the mechanism.
Learning 3
When there's no ground truth, your critic is your moat
This is the lesson that separates verticals. In code, verification is cheap: run the tests. In presentations, “is this good?” has no oracle. So we had to build one.
Chronicle runs on a multi-agent orchestrator where generation is only half the system. Dedicated critic agents review every output before a human sees it: Is the narrative arc coherent? Does slide 7 actually support the claim on slide 2? Would this chart survive a skeptical CFO? We encoded years of accumulated taste (what makes a deck land versus die) into evaluators that grade relentlessly and never get tired at slide 40.
Anyone can prompt a model to generate slides. The defensible asset is the judgment layer, because it can only be built from domain obsession, real user outcomes, and thousands of examples of good and bad. Generation is a commodity. Evaluation is the moat.
Ask one question of any vertical agent, whether you're building it or buying it: who checks the work? If the answer is “the user,” the product is unfinished. Generation is table stakes; judgment is the product. Fund “is it good?” like it's half your roadmap, because it is.
Learning 4
Own the brief, because users can't articulate what they want
We assumed prompt quality would improve as users learned the tool. It didn't, because the problem was never prompting skill. It's that people genuinely don't know what they want from a deck until they see a wrong version of it.
“Make me a fundraising deck” hides fifty unmade decisions: audience, stage, the one belief the room must leave with, what to omit. A naive agent guesses all fifty silently and gets graded on the guesses. So we moved the agent upstream: before building, Chronicle interrogates the brief the way a great chief of staff would. Who's the audience? What's the ask? What does the skeptic in the room believe today?
Something unexpected happened: users told us the interview was valuable even before the slides existed. The agent was debugging their thinking, not just their deck.
In any judgment-heavy vertical, the intake is the product. The gap between what users say and what they need is where vertical agents win or die. Don't make your agent a better guesser. Make it a better questioner.
Learning 5
Automate the assembly, promote the user
The fear question in every vertical: “Is this replacing me?” The honest answer, and the design principle, is role promotion.
Look at where the hours actually go in presentations: dragging boxes, fixing fonts, rebuilding the chart marketing broke. Almost none of the time goes to the thing the deck exists for, which is changing someone's mind. The bottleneck in presentations was never making slides. It was making the argument.
Painting ran this experiment first. For centuries, painters spent their days grinding pigment and mixing oils, mechanical preparation that had nothing to do with seeing. Then the collapsible paint tube arrived in 1841 and absorbed all of it. Painters didn't become obsolete; they walked out of the studio, chased daylight, and invented Impressionism. Renoir went as far as saying that without paint in tubes there would have been no Monet, no Cézanne. The tube didn't speed up the old paintings. It made a new kind of painting possible.
A good vertical agent is the paint tube: it absorbs the grinding (formatting, assembly, consistency) so the human can leave the studio (narrative, judgment, persuasion). When we evaluate a Chronicle feature now, the bar isn't “does this save time?” It's “does this move the user up the stack?”
Map your vertical's hours into mechanical versus judgment work. Your agent should devour the first category completely and amplify the second. If your roadmap automates judgment while leaving assembly manual, you've built it upside down.
The playbook, in one slide (naturally)
- Novelty budget: keep the artifact boring, make the workflow revolutionary. Cursor kept the codebase, Shortcut kept the grid; treat your vertical's file format as sacred.
- Constrained canvas: define the legal moves, then let the agent play. Freedom is what makes model output unreliable; grammar is what makes it shippable.
- Critic as moat: in subjective domains, evaluation beats generation. Anyone can generate; only domain obsession can grade.
- Own the brief: the intake interview is where quality is decided. Don't build a better guesser; build a better questioner.
- Promote the user: absorb the mechanical, amplify the judgment. The bar was never “does this save time?” but “does this move the user up the stack?”
The verticals with compilers got their agents first (code with Cursor, spreadsheets with Shortcut, SQL with a dozen text-to-query tools). The verticals running on taste (presentations, design, writing, strategy) are harder, later, and far more valuable, because the moats are real. Today's decks are studio paintings, made mostly of grinding.
And the tube is coming whether you build it or buy it. If you're a founder, these five lessons are a build spec. If you're a leader deploying agents across an enterprise, or a ministry, they're a diligence checklist: does this agent keep the artifact boring, constrain its canvas, ship with a critic, own the brief, and promote your people? History says the fastest adopters won't be where the models are built, but where the legacy is thinnest. The paint tube was picked up first by the painters least invested in the old studios.