The AI Project Manager that turns transcripts into vault tickets — humans review, never start blank. Three agents read what humans read; the pre-commit hook is the safety net. Not a writing assistant. Production.
Hand-authoring tickets is the bottleneck most companies don't measure. A 90-min meeting eats roughly 3 hours of someone's time — listening back, transcribing, deciding what counts, placing into the right epic, estimating, wiring dependencies. By 5pm the details are blurry; by Monday they're lost. Our pipeline replaces that loop. Three agents — transcript-extraction → product-manager → ticket-file generator — turn the same meeting into 5–10 fully-cited tickets in 20 minutes. Humans review the diff and commit. The pre-commit hook validates the schema and rejects bad output. AI gets no special treatment.
If you only have 5 minutes: §02 (the Friday-call vignette) → §05 (the architecture) → §13 (closing). If you're a CFO/COO benchmarking spend: §07 (the bet we already won) + §10 (what it costs). If you want a fit call this week: jump to §13.
A product lead finishes a 90-minute customer call at 4pm on a Friday. Five action items, three decisions, a contradicted assumption, two new dependencies. They have to capture all of it before Monday or it evaporates. They block 90 minutes of their own time on Monday morning to listen back at 1.5×, take notes, draft tickets in ClickUp. By 11am Monday the tickets exist. By 11am Tuesday the team realizes three of them duplicate work already in flight and one missed the actual decision the call settled. The PM lost three hours; the team lost a sprint of clarity.
A consultant runs four discovery calls in a week and still has to bill against deliverables. The transcripts pile up in ~/Downloads. The "I'll write it up Sunday" pattern degrades by call three. By call four they're paraphrasing from memory, citing nothing, and the proposal that lands Monday reads like generic AI consulting prose because that's what running on memory produces.
An engineering lead receives a 2,099-line transcript from a multi-stakeholder call (the operator, two prospects, a partner). Inside it: pricing decisions, technical commitments, scope-shifts, a quiet contradiction between what was said in March and what was said today. The cost of *missing* one of those isn't theoretical — it's a misaligned spec, a re-read deal, an erosion of trust that doesn't surface until week six.
This is the pattern. The bottleneck isn't thinking. It's transcription. AI is genuinely good at transcription. The hand-authored ticket flow is the bottleneck nobody is measuring because everyone is paying it.
4:02 PM Friday. The call ends. The transcript drops intotranscripts/— 2,099 lines, three speakers, 90 minutes. The product lead types one command:/pm-from-transcript transcripts/2026-04-03_call.md. The pipeline starts.
4:04 PM. The transcript-extraction agent finishes. It produces a structured pass — pains, decisions, action items, BANT signals, stakeholder positions, open questions — every item linked to the exact line range in the transcript that produced it. Nothing summarized away; nothing hallucinated. The agent already knows the project's vocabulary because it was loaded with the project's CLAUDE.md.
4:11 PM. The product-manager agent reads the structured pass alongside the project's existing tickets and the schema doc. It produces proposal.yaml — seven new tickets, each with epic placement, story-points estimate, RACI inferred from action-item ownership, dependencies wired to existing tickets. Plus an "ambiguities" block: "Action item from Doug at 1:42:18 — could be owned by either Dima or Mike. Default: Dima. Confirm?" Plus a "duplicates detected" block: "Proposed T-013 looks similar to existing T-011 (cosine 0.82). Recommend merge into T-011 with new AC."
4:14 PM. The product lead opensproposal.yamlin their editor. They confirm Dima owns the disputed action item. They accept the merge into T-011. They reject one ticket as scope-creep, edit another's title, and approve. They run/task review-pmwhich writes the seven ticket files intotickets/<epic>/<story>/. Frontmatter is populated; bodies are populated; activity log first entry: "Generated by AI-PM from transcripts/2026-04-03_call.md#L1532-L1607."
4:21 PM. The product lead runsgit diff, reads the seven tickets, edits two AC clauses, runsgit commit. The pre-commit hook validates the frontmatter — RACI present, dependencies resolve, epic exists, owner is in the team list. Commit lands. Total: 19 minutes from call-end to ticket-merge.
That's what the operator gets. A Friday afternoon that ends with the work captured, not deferred. Monday morning starts with delivery, not transcription. The team's signal-to-noise on tickets goes up because the synthesizer, unlike a tired PM at 5pm, actually reads the project's existing tickets before proposing new ones. The PM stops being a transcription bottleneck and starts being a reviewer. Which is the higher-leverage version of their job anyway.
(Vignette anonymizes a real session. The 19-minute end-to-end is from a 2026-04-03 call processed against the live pipeline. Names changed; the rest is transcript.)
Every product team in 2026 talks about AI productivity. Almost none measure the single highest-volume task that AI is unambiguously better at than a tired human: turning unstructured speech into structured work items. The reason it doesn't get measured is the reason most companies are still hand-authoring: it feels like the PM's job, the hours are spread thin, and nobody has run the math on what the team actually pays for it.
The math, for a 25-person product org running six 90-minute meetings a week: ~18 hours of senior PM time per week on transcription-and-ticketing. At a fully-loaded $200/hour, that's $3,600/week, $187,000/year of PM salary spent on a task that AI does in 20 minutes per meeting. Most companies, asked where their PM-Vault lives, will point at ClickUp. Their actual PM-Vault is the inside of three senior people's heads — and it leaks every weekend.
What we ship isn't a chatbot or an AI assistant. It's a pipeline. Three agents in series, each with a single job, each citing its sources to the line in the transcript, each producing structured output the next stage can consume. A pre-commit hook in front of the vault rejects malformed output the same way it rejects malformed human output. AI gets no special treatment. The human is the gate.
Anyone can ask Claude to "summarize this call into tickets." That's a writing assistant. What we ship is production. The difference is the schema, the review gate, the citation chain, the duplicate detection, the project-context awareness, and the fact that the output goes into a system of record under version control — not into a Slack thread that evaporates by Tuesday.
Before building this, we ran the same evaluation we run for every Cone Red Practice Area. Six alternatives. Each one a thing you have already considered or been pitched in 2025–2026. The table is the case for not buying any of them as the painkiller.
| Option | What it actually is | Why we passed |
|---|---|---|
| ClickUp / Linear / Jira AI features | "Summarize this comment thread into tasks" inside an existing PM tool | The output is shaped by the PM tool's data model, not by the team's actual schema. No transcript-line citations. No project-context awareness across multiple deals. Locks you deeper into the SaaS. |
| Notion AI / Coda AI | Generic "draft tasks from this page" inside a doc tool | Optimised for reading, not for systems-of-record. No schema validation. No commit gate. The output reads OK on Monday and rots by Friday. |
| Custom Zapier + ChatGPT | Glue: transcript → ChatGPT → "make tickets" → ClickUp API | Hallucinations end up in your system of record because there is no review gate. No project-context. No structured intermediate. This is how most teams discover the failure mode the hard way. |
| Specialized "AI meeting assistants" (Otter, Fellow, Granola, Read.ai) | Auto-transcribe + summarize + push action items to integrations | Strong on transcription; weak on synthesis into a project's actual ticket schema. Push-to-Asana flows degrade once your team's structure diverges from the vendor's defaults. Useful as upstream input; not the painkiller. |
| "Wait for ClickUp / Atlassian / Linear to ship the killer agent" | Trust the incumbent | The incumbent's economic incentive is to keep your data inside the SaaS. The pipeline a vendor will ship is one that scales their seats, not your repo's signal-to-noise. Their interest is not your interest. |
| "Build it from scratch" with LangChain / a custom agent framework | Internal R&D project | The "I don't know what to evaluate" trap. Without a working baseline you can't tell if your design is right. We treated it as input, not output — borrowed the strongest frame, replaced the substrate. |
We didn't pick one and stop. We synthesized. We took the best mental model in the space (the vault-as-tickets pattern, with a schema enforced by a pre-commit hook) and built a three-stage pipeline on top of it. The result reads what humans read, writes what humans review, and stops where humans always stopped: at the commit.
The pipeline is deliberately small. Four moving parts. Each one does a single job, cites its work, and hands off structured output to the next stage. The pre-commit hook is mechanical — same gate every human passes through.
Reads the transcript line by line. Emits structured JSON: pains, decisions, action items, BANT signals, stakeholder positions, open questions. Every item links to the exact line range that produced it. Loaded with the project's CLAUDE.md so it speaks the team's vocabulary. (Internal codename: Conversa.)
Reads the extraction alongside the existing ticket index and the schema doc. Decides: which items become tickets, what's the right epic / story placement, what's the estimate, who's responsible, what's blocked by what. Outputs proposal.yaml with new tickets, an "ambiguities" block for things it isn't sure about, and a "duplicates detected" block (cosine ≥ 0.75 = flag). (Internal codename: Prody.)
After human review, writes the actual ticket files into tickets/<epic>/<story>/<id>.md. Frontmatter populated (RACI, deps, state, points, risk, sources, AI-context refs). Body sections autopopulated: Context, Acceptance Criteria, Definition of Done, Out of Scope, Activity Log. Writes but does not commit. (Internal name: PM-Vault.)
Mechanical, not an agent. Validates frontmatter against the schema: invalid output blocks the commit. AI gets no special treatment — same gate every human passes through. The first thing that fires when AI hallucinates a malformed assignee or a broken dependency reference.
Why three agents, not one. A single agent that "reads a transcript and writes tickets" is the writing-assistant pattern — works on demos, fails in production. Splitting the pipeline into extract-then-synthesize-then-generate gives three things: (1) each stage is auditable (the structured intermediate is human-readable), (2) each stage runs the right model for the cost (fast model for extraction, stronger model for synthesis, cheap model for generation), (3) each stage has a hand-off the human can intercept. If the synthesizer's proposal.yaml looks wrong, you fix it once, and the generator is forced to comply.
The hand-off shape matters more than the agent names. Most "AI ticket generators" run end-to-end without a structured intermediate. That's how you get tickets that read OK and have a missing assignee, a broken dependency, and a hallucinated story-point estimate. The intermediate is the painkiller.
Scars sell. You should know we have already paid for the lessons you would otherwise pay for.
First version: one agent, transcript in, tickets out. Looked clean on the demo. In production, ~25% of tickets had a missing or wrong owner — the agent had inferred from speech patterns rather than reading the project's RACI conventions. Cost to fix: split synthesis from generation, force the synthesizer to consult the project's existing tickets and assignees, surface ambiguity rather than guess. Ambiguity flags are the credibility signal — never let an agent silently guess.
We tried trusting the agent's output. We got tickets with `assignee: "the team"` and `depends_on: [T-XXX, T-YYY]` (placeholders the agent generated when it didn't know). Cost to fix: a pre-commit hook with strict frontmatter schema that rejects placeholders, undefined assignees, and broken references. The hook is what makes this production, not a writing assistant.
Mike Leone of Omdia named the second half of this pattern: "You test on a curated dataset, the AI looks amazing. Then you point it at production. Fifteen years of SharePoint folders. Teams threads nobody's cleaned up since 2021. Governance overhead alone can get close to what they're spending on the technology itself." Running a frontier model on every message is what most consumer "AI memory" products effectively do. We split into a free heuristic pass first (NER + importance scoring) and an event-triggered LLM pass. The expensive model only runs on signals that cleared the bar.
Ticket #5 from the Friday call should have been merged into ticket #11 from the Tuesday call — same scope, two stakeholders, three weeks apart. v0 of the pipeline missed it because the synthesizer had no view of the existing ticket index. Cost to fix: title/AC embedding similarity + a duplicate-detection block in proposal.yaml. The synthesizer reads the existing index before proposing new tickets — that's the cheapest dedup that works.
The technical pipeline can be perfect and the rollout still fails — because the team that used to hand-author tickets sees AI-PM as a threat to the part of their job they were measured on. Writer × Workplace Intelligence (Apr 2026, n=2,400): 29% of knowledge workers admit to sabotaging their company's AI strategy. 44% among Gen Z. Tactics: metric tampering, performative compliance, refusing mandated tools. Cost to fix: tie performance reviews to outcomes, never to "AI usage" or token spend. Frame the pipeline as "the PM stops transcribing and starts reviewing" — a higher-leverage version of the same job. Carl Eschenbach, CEO of Workday: "Employees today believe they're competing against AI. They're not. They're competing against their peers who are using AI."
Each of these is roughly two weeks of work to discover, scope, and fix when you encounter it cold. We have already paid that tab.
We refused to hire a $5K/month project manager. We built this pipeline instead. Runs three projects in parallel; onboards to any new task, industry, or stakeholder instantly. The CR practice has shipped 150+ enterprise AI projects on this pattern. Most credible kind of evidence: we did this to ourselves before pitching it.
Real Friday call: 90 minutes, three stakeholders, scope-shifts, contradicted assumption. Pipeline produced 7 tickets across decisions, build commitments, and research items, plus 2 ambiguity flags and 1 duplicate-merge. Validated against the hand-derived tickets that had been written the week before. Coverage: 86%. Noise: 14%. Above the 80%/≤20% bar set at design time.
The numbers are not press-release figures. They are reproducible from a real transcript with line citations, a hand-derived ground-truth set, and a commit history showing the pipeline's first run. The full validation harness is part of the deliverable. The fact of a hand-derived ground truth set is the credibility signal — and most products in this space cannot show one.
Why coverage matters more than precision here. A PM hand-deriving tickets from a 2,099-line transcript at 5pm misses things — that's the failure mode we're replacing, not the one to over-correct against. The pipeline's job is to surface every plausible ticket plus the ambiguity flags, and let the human decide. A 14% noise rate means the human deletes ~1 ticket per call. A PM losing a real action item to fatigue costs the team a sprint of clarity. Trade-off accepted, deliberately.
Today's ritual: PM writes "I'll capture the actions" in the chat and blocks Sunday afternoon. New ritual: PM ends the call, runs /pm-from-transcript, opens proposal.yaml in 8 minutes. The hours-to-decision compress to minutes-to-review.
Tickets stop being authored in a SaaS UI and start being authored as markdown files under version control. Every ticket carries a sources_from_transcript reference — you can cite the moment in the call that produced the ticket. The transcript becomes part of the audit trail, not just a Slack drop.
Today: a tired PM defaults ownership to whoever's name they remember. Output looks crisp; reality is fuzzy. New: the synthesizer flags ambiguity explicitly. The diff shows you the flags. You resolve them once, on the way in. Visible ambiguity is a feature, not a bug.
Three months in, you have 200 tickets. The synthesizer reads the existing index before proposing new ones, and surfaces likely merges with cosine similarity scores. Your ticket count stops compounding into noise.
The same pipeline runs across every project's vault. A pattern that surfaced in three transcripts across two deals — say, a recurring objection from procurement officers about audit logs — surfaces as a candidate for a playbook entry, not as a fragment hidden in three different ClickUp boards.
The role shifts from "person who writes things down" to "person who reads things and decides." This is the higher-leverage version of the job — and the version most senior PMs already wish they were doing. Tie performance reviews to decisions logged, dependencies caught, scope-creep killed, not to ticket count or hours spent in ClickUp.
CLAUDE.md.Pipeline runs on demand or on transcript-landing. Synthesizer batches across multi-call deals, dedupes within a window. The PM still owns review-and-commit cadence — usually at end-of-day, not real-time. This is not a real-time agent platform. It's an asynchronous PM substrate.
The pipeline is deliberately cheap to operate at scale because it makes three choices most competitors don't.
Stage 1 (extraction) is mechanical structure-from-text. A fast open-weight model handles it for a fraction of the cost of running a frontier model on every transcript. Stage 2 (synthesis) is where reasoning matters; that gets the better model. Stage 3 (generation) is template-driven; cheap model again. Per-meeting cost in a typical deployment: under $1.
The vault is a git repository. Your tickets are markdown files. There is no per-seat SaaS bill, no per-API-call retrieval tax, no vendor lock-in to a closed PM product. The economics scale with calls, not seats.
Stage 1 catches the structural elements (named entities, dates, dollar amounts, action verbs, decision markers) with deterministic parsing before invoking the LLM. The LLM only fires on the parts where reasoning is needed. Per-meeting economics scale with meeting signal, not meeting length.
Specific dollar figures vary by deployment shape and team size; they're part of the commercial conversation. The architectural commitment is unambiguous. The PM-time savings dwarf the compute cost by three orders of magnitude.
Honest status, plainly: the pipeline runs internally at Cone Red. Stage 1 (extraction) is shipped and reused across /ingest-transcript on every CR call. Stage 2 (synthesis) and Stage 3 (generation) are at v0.1, validated against the test case, scheduled for full productization concurrent with our internal vault-as-tickets cutover (mid-May 2026). External pilots will run on the same substrate, scoped to client transcripts.
| Component | Status | Result |
|---|---|---|
| Stage 1 — Transcript extraction | Shipped | Used in every CR /ingest-transcript call since 2026-Q1 |
| Pre-commit hook (vault schema) | Shipped | Catching real schema violations daily — the gate is real |
| Stage 2 — PM agent (synthesizer) | Active | 86% coverage on test case; v0.1 in production for CR projects |
| Stage 3 — Ticket-file generator | Active | v0.1; emits valid frontmatter against schema |
| Duplicate detection (cosine similarity) | Scheduled | v1 ships May 2026 alongside internal vault cutover |
| Cross-call merge / multi-transcript synthesis | Scheduled | v2 — process-sequentially in v1, dedupe in synthesizer |
| External client pilots | Open | Q3 2026 cohort — 3 design partners |
The pipeline runs against itself daily. Every Cone Red call goes through Stage 1; every Cone Red ticket since the vault-as-tickets cutover passes through the pre-commit hook. We are the first design partner. The case for buying it from us is the case for buying it from the firm that paid the integration tab on its own engagement portfolio first.
The table is the calendar, plain. Stage 1 + the schema gate are running. Stage 2 and Stage 3 are at v0.1 — usable, not yet best-in-class. Duplicate detection and cross-call merge are scheduled with quality gates that must hold before production rollout. We are not asking you to take "this all works today" on faith — we are asking you to look at the gates and decide if our discipline maps to your risk appetite. If you need cross-call merge production-grade before signing, we'll tell you on the first call which pilots are the right shape.
Credibility bank. We overfund it on purpose.
If you're looking for any of those, this is not the right purchase. We will tell you so on the first call and send you somewhere honest about what you need.
The bottleneck in product organizations isn't strategy. It's the half-shift on Sunday afternoon when a PM is hand-deriving tickets from a Friday transcript at 1.5×.
Bret Taylor — CEO of Sierra, Chair of OpenAI — put the broader version of this in nine words: "Big companies struggle to adopt AI because they are shipping their org charts." The org chart wins because every AI tool gets bolted onto a team-by-team workflow without changing how work flows across the team. The PM's transcription burden is the most expensive piece of that pattern. Replace the burden, the role shifts from writes things down to decides what matters. The team's signal-to-noise on commitments goes up.
We built that. It works on our own engagements. The validation harness is reproducible. The deployment shape is engineered for clients who want sovereignty over their tickets and a clean exit if they ever want one.
If you've read this far, you're past category-curiosity. Two ways in, depending on where you are:
We look at your meeting cadence, your transcript pipeline, your existing ticket schema. We tell you honestly whether this is a fit. Bring one transcript and the tickets your team hand-derived from it. We'll show you what the pipeline produces against the same source. First slots usually open within 48 hours.
Book direct → or
email dima@cone.red
subject · "AI-PM Pipeline — fit call"
The AI-First Company Handbook covers the broader vault-as-tickets pattern this pipeline rides on top of. If your company isn't yet on a markdown-vault substrate, start there. The pipeline is the leverage; the vault is the foundation.
— The Cone Red AI · AI-PM Pipeline Practice
A Practice Area within the Cone Red AI-First Transformation Practice · 2026-04-29