Build AI Meeting Intelligence: From Recordings to Decisions, With Cost Per Meeting and Failure Modes (2026)

$ $ meetingctl show-item mtg_8f2a --id itm_04
type            action_item
title           Send the revised SOC 2 scope to Northwind before Friday
owner_resolved  daniel.okafor@example.com  (attendee, join_log match)
owner_confidence 0.94
due_date        2026-08-28  (resolved from "before Friday", meeting date 2026-08-24)
span_start      00:31:12.480
span_text       "I'll get the revised scope over to Northwind before Friday"
span_verified   true   (exact substring of transcript segment 214)
speaker_turn    turn_211  diarisation_label spk_2  overlap_flag false
idempotency_key mtg_8f2a:action_item:sha256(span)[0:16] = 7c1f9ab3e40d2286
gate_score      0.88  ->  auto_write
written_to      linear:ENG-4417  (created 2026-08-24T14:07:02Z, reversible)
$ $ meetingctl show-item mtg_8f2a --id itm_07
type            action_item
title           Ask Legal whether the DPA needs re-signing
owner_resolved  null   (no first-person commitment in span)
span_text       "someone should probably ask Legal about the DPA"
gate_score      0.41  ->  human_confirm_queue  (reason: unowned_hypothetical)

import { z } from "zod";

export const ExtractedItem = z.object({
  type: z.enum(["decision", "action_item", "risk", "open_question"]),
  title: z.string().min(6).max(160),
  span_text: z.string().min(15),        // must appear verbatim in the transcript
  span_turn_id: z.string(),             // which diarised turn it came from
  claimed_owner: z.string().nullable(), // resolved later against a closed set
  claimed_due: z.string().nullable(),   // relative language is fine here
});

export type Item = z.infer<typeof ExtractedItem>;

type Turn = { id: string; speakerEmail: string | null; text: string; overlap: boolean };
type Context = {
  turns: Map<string, Turn>;
  attendees: Set<string>;      // emails on the calendar invite
  directory: Set<string>;      // everyone in the company
  meetingDateIso: string;
  timezone: string;
};

export type Verdict =
  | { ok: true; owner: string | null; dueIso: string | null; score: number }
  | { ok: false; reason: string };

const COMMITMENT = /\b(i(?: will|'ll| can| am going to)|we(?: will|'ll)|let me|i'm going to)\b/i;

export function verify(item: Item, ctx: Context): Verdict {
  const turn = ctx.turns.get(item.span_turn_id);
  if (!turn) return { ok: false, reason: "unknown_turn" };

  // 1. free: the span must literally exist in the turn it claims to come from
  if (!norm(turn.text).includes(norm(item.span_text))) {
    return { ok: false, reason: "span_not_found" };
  }

  // 2. free: an action item needs an actual commitment, not a hypothetical
  if (item.type === "action_item" && !COMMITMENT.test(item.span_text)) {
    return { ok: false, reason: "unowned_hypothetical" };
  }

  // 3. free: owners come from a closed set. Never accept free text.
  let owner: string | null = null;
  if (item.type === "action_item") {
    const candidate = item.claimed_owner ?? turn.speakerEmail;
    if (!candidate) return { ok: false, reason: "no_owner" };
    if (!ctx.attendees.has(candidate) && !ctx.directory.has(candidate)) {
      return { ok: false, reason: "owner_not_a_real_person" };
    }
    owner = candidate;
  }

  // 4. free: dates are parsed deterministically against the meeting date
  let dueIso: string | null = null;
  if (item.claimed_due) {
    dueIso = resolveRelativeDate(item.claimed_due, ctx.meetingDateIso, ctx.timezone);
    if (!dueIso) return { ok: false, reason: "date_unresolvable" };
  }

  // Speaker confidence is the term that decides auto-write. Overlapping
  // speech is where diarisation fails, so it costs the item its autonomy.
  const score = turn.overlap ? 0.55 : 0.9;
  return { ok: true, owner, dueIso, score };
}

function norm(s: string): string {
  return s.toLowerCase().replace(/[^a-z0-9 ]/g, "").replace(/\s+/g, " ").trim();
}

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { createHash } from "node:crypto";
import { z } from "zod";

const server = new McpServer({ name: "tracker", version: "3.0.1" });

server.registerTool(
  "create_task",
  {
    title: "Create a task from a verified meeting action item",
    description:
      "Creates one task in the tracker from an action item that has already " +
      "passed verification. The task is attributed to its meeting and quotes " +
      "the transcript verbatim. Safe to retry: an identical item returns the " +
      "task created the first time. Do NOT call this for decisions or risks - " +
      "use write_decision, which does not create work for anyone.",
    inputSchema: {
      meetingId: z.string(),
      spanText: z.string().min(15),
      spanTimestamp: z.string(),
      title: z.string().min(6).max(160),
      ownerEmail: z.string().email(),
      dueIso: z.string().nullable(),
      projectKey: z.string(),
    },
  },
  async (args, extra) => {
    // Workspace comes from the verified request context, never the model.
    const workspaceId = requireWorkspace(extra.requestInfo);

    // Key is derived server-side. A client cannot weaken idempotency by
    // choosing a worse key, and re-extraction produces the same span hash.
    const spanHash = createHash("sha256").update(norm(args.spanText)).digest("hex").slice(0, 16);
    const idempotencyKey = args.meetingId + ":action_item:" + spanHash;

    const existing = await tracker.findByIdempotencyKey({ workspaceId, idempotencyKey });
    if (existing) {
      // A retry is normal. Return the original, do not create a second task.
      return ok({ taskId: existing.id, created: false, url: existing.url });
    }

    const owner = await directory.resolve({ workspaceId, email: args.ownerEmail });
    if (!owner) {
      return ok({ error: "owner_not_in_workspace", taskId: null, created: false });
    }

    const description = [
      args.title,
      "",
      "> " + args.spanText,
      "",
      "Said at " + args.spanTimestamp + " in meeting " + args.meetingId + ".",
      "Created automatically. If this is wrong, click Reject and it will be removed.",
    ].join("\n");

    const task = await tracker.createTask({
      workspaceId,
      projectKey: args.projectKey,
      title: args.title,
      description,
      assigneeId: owner.id,
      dueDate: args.dueIso,
      idempotencyKey,
      source: { kind: "meeting", meetingId: args.meetingId, spanHash },
    });

    return ok({ taskId: task.id, created: true, url: task.url });
  },
);

function ok(payload: unknown) {
  return { content: [{ type: "text" as const, text: JSON.stringify(payload) }], structuredContent: payload };
}

function norm(s: string): string {
  return s.toLowerCase().replace(/\s+/g, " ").trim();
}

1. Week 1
   Capture, consent, retention

   Bot join or host SDK, per-participant consent state stored as a precondition on the storage write, retention policy. Mostly legal design with code attached, and impossible to retrofit.

2. Week 2
   Transcript pipeline and journal

   Batch ASR with diarisation, transcript store with turn-level segments and spans, run and stage tables, cost attribution with a rate-card id. No demo value, total dependency.

3. Weeks 3‑4
   Speaker resolution

   Calendar and directory integration, join-log matching, guests without directory entries, phone dial-ins, overlap flagging. Sounds small; it is the accuracy ceiling of the product.

4. Weeks 5‑6
   Typed extraction and verification

   Overlapping chunks, consolidation with span dedup, the item schema, the commitment check, deterministic date resolution, closed-set owner resolution. This is the product.

5. Week 7
   MCP write surface

   Eight tools, idempotency on meeting id plus span hash, attribution embedded in every created object, one-click reversal. Deliberately no closes, no reassignments, no stage changes.

6. Weeks 8‑9
   Index, ACLs and entity graph

   Turn-aligned chunking, hybrid search, the ACL predicate inside the query, decision entities with topic keys and supersedes edges. The half that compounds in value.

7. Weeks 10‑11
   Confirm queue, evals, rollout

   The one-click confirmation interface, dashboards, a hand-labelled eval set of twenty real meetings, and three weeks with one team where you read every rejected item together.