Four ways we tried to trigger an AI agent. Only the fourth one worked.

Notes from a year of building meeting-notes automation for an India-based venture fund — and what it taught us about the part of AI workflow tools nobody talks about.

The first time we shipped it, it was a cron job. Cron jobs are supposed to be boring. This one got renegotiated three times.

It ran every two hours. It pulled meeting transcripts from four AI notetakers, ran them through Claude, mapped each one to a startup in the fund's portfolio, and dropped a structured due-diligence memo into the right ClickUp doc. End-to-end. No human in the loop. That was the spec. That was what we'd agreed on, in writing, with timelines.

It worked the day we shipped it.

Nobody used it.

Most of what I now put into agency contracts about scope, ambiguity, and "human-in-the-loop" came from this one project — a small VC fund in India, four notetakers (Fireflies, Read.ai, Fathom, Granola), and a trigger that wanted to live somewhere we hadn't thought to look.

If you've built anything that turns conversations into structured work — sales tools, recruiting pipelines, IC memos, status reports — there's a chance you've made the same mistake we made. We thought we were building a memo generator. The interesting part — the part nobody warns you about — turned out to be everywhere else.

Here's what we tried.

Layer 1: Cron, every two hours

Original spec, written in March: backend service, no UI. Cron pulls transcripts, Claude analyzes, ClickUp updates. The fund's analyst opens her laptop on Monday morning, Bangalore time, and the previous week's calls have already been written up. We shipped it in three weeks. It worked.

About a month in, I learned she was still writing memos by hand on Saturday afternoons.

The transcripts were appearing in ClickUp on schedule. They were accurate enough — Claude was correctly identifying which startup each call was about, correctly extracting the diligence questions, correctly drafting the answers. The memos were good. She just wasn't reading them.

We got on a call. She was polite about it. She said, in effect, that she wanted to see what was about to happen before it did. Or, as she put it more carefully a minute later: she wanted to choose what went in.

The memos were good. They just weren't hers.

This is the thing nobody mentions in AI-workflow demos: an analyst's relationship to a memo isn't "did the AI write a correct one." It's "is this defensible in front of the partners on Friday." Correctness is necessary and not sufficient. Authorship is sufficient. We had built a system that produced correct outputs that nobody felt comfortable defending.

Layer 2: Toggles

We added a UI. Specifically: a list of her Google Chat spaces, with a switch next to each one, controlling which conversations the AI could read for context.

This sounds tiny. It was the first time the system felt like hers.

The Google Chat data was always going to be useful — founders text the fund constantly, the deepest signal lives in those threads. But pulling it without permission felt invasive even to me. So we exposed the choice. You decide what the AI sees.

The number of memos she touched went from zero to most of them. Same model. Same prompts. Same outputs. Different feeling.

I think about this layer the most. We added almost no functionality. We just moved a decision from us to her. Adoption tripled. There's a version of this lesson that's about consent and AI — I'm not the right person to write it. The narrower lesson is that a toggle is a more powerful form of automation than a workflow.

Layer 3: The checkbox

Now she trusted the inputs. She wanted to control the outputs.

So we added a "Generate AI memo" checkbox on each ClickUp task. Tick it, the agent ran. Don't tick it, nothing happened. Clean. Explicit. Consent-forward.

Wrong.

Not because it broke — the checkbox worked perfectly — but because nobody ticked it. Two weeks in, a third of the portfolio had untouched checkboxes. Calls were happening. Memos were not.

I sat with this for a while. It made no sense. We had given her exactly the control she'd asked for, and she wasn't using it. When I asked her why — over chai on a Wednesday afternoon, slightly sheepish on both sides — she told me she forgot the checkbox existed. She'd open the task to update the stage, write a comment, change the assignee, and the checkbox would just sit there. The AI was a secondary action on the task, and secondary actions in busy software die.

We had built consent without context. The trigger lived in the wrong place — visible, but disconnected from the work she was actually doing.

Layer 4: Watching the work itself

The breakthrough wasn't a feature. It was looking at her screen for an hour.

She was moving cards. EP → FM → SM → Decision. That was the real job. Every other action on the task was incidental to that. The checkbox was incidental. The AI memo was incidental. The card movement was the only thing that was always-on.

So we moved the trigger there.

Now: when a card changes stage in ClickUp, a webhook fires. Ten minutes later — to give her time to change her mind, or to add a quick note for context — Claude gathers every conversation that happened while the startup was in that specific stage, fills the relevant section of the doc, and posts a four-question summary as a comment on the card. The card movement is the trigger. There is nothing else to remember.

We ended up calling the system Quorum, after the parliamentary term — the gathering sufficient for a decision. Which is what an IC memo is, when you write one honestly.

Adoption climbed from a third-of-portfolio-untouched to nearly every memo running automatically inside a week. Not because the AI got better. Because the trigger finally lived where her hand already was.

The mistake is thinking the product is the AI. The product is the trigger. Where you put it, who controls it, what happens when it misfires. The model is the cheapest part.

There's a subtle technical point that I'd argue is the actual moat. Startups don't move forward in a straight line. They go EP → FM → back to EP → FM again, sometimes twice. If you naively dump every transcript into the latest stage's doc, you smear evidence across stages and the memos turn to mush. We had to track time-windowed evidence per stage: which calls happened during the most recent occupancy of FM, specifically. The trigger is the easy part to describe. The bookkeeping behind it took a week.

I'll skip the prompt engineering. It's less interesting than people think. Two paragraphs of system prompt, a list of forty-two diligence questions, a Sonnet 4.6 call. The prompt got shorter over time, not longer. The version in production today is about a third the length of what we shipped in week one and produces strictly better memos. There's a lesson hiding there. It's not this post.

What broke

Three things, while we're being honest.

The ClickUp webhook handler ran synchronously for the first month. ClickUp's timeout is thirty seconds. Our pipeline was usually faster than that, until it wasn't. We discovered, on a Tuesday, that the handler had been failing for 104 consecutive deliveries. Nobody had noticed because the queue had no observability and the analyst had been editing memos manually that week without realizing they hadn't been auto-generated. We moved everything to a delayed queue with retries. The ten-minute delay turned out to be a feature, not a workaround — gives her room to undo a misclick. The bug picked the design.

Fireflies' GraphQL API was silently dropping pages of results because of a deprecated parameter we'd been passing for a month. No error. No warning. Just empty arrays where there should have been transcripts. Found it by hand-querying their schema at 1 a.m. Bangalore time, with a cold cup of tea I'd forgotten about three hours earlier.

Granola moved their integration from MCP to a personal API key one Monday morning. The build broke. We rewrote the adapter in thirty-six hours. I have opinions about emerging-platform integrations now. They are not flattering opinions.

What I'd put in a contract today

If you're building AI workflow tools, the cycle I want to spare you is this: ship the spec, watch nobody use it, slowly realize that the trigger you assumed was correct is actually the entire product. The model is commoditized. The integrations are commoditized. The dashboard is commoditized. The trigger — where it lives, what it watches, when it fires, how the user feels in relation to it — is the only thing left that compounds.

Every AI tool I've shipped since has gotten the same question first: what does the user already do that we can attach to? Not what feature to add. Not what UI to build. Where, in their existing motion, can we put a hand?

If the answer is "we'll add a button" — you're at Layer 3. You'll find out.

The trigger is the product.

I have no relationship with Anthropic, ClickUp, or any of the notetakers mentioned. We just build with them. Quorum was deployed for a single fund and is not a product we sell — but the pattern is portable, and we are happy to build something similar for your team.