Live Alignment Copilot

AI drafts live meeting maps. Presenters decide what the audience sees.

Comment

Inspiration

Live meetings create alignment debt. Teams make decisions, discover blockers, and sketch workflows in conversation, but the shared artifact usually appears later, after someone manually rewrites the meeting into notes, diagrams, or slides. That delay is especially risky in live sales calls, support escalations, requirements workshops, and webinars where the audience needs a clear shared view while the conversation is still happening.

Live Alignment Copilot explores a narrow, safer version of AI assistance for that moment: AI can propose structure, but a human presenter controls what is published.

What It Does

Live Alignment Copilot turns a meeting transcript into reviewable diagram changes. The UI has three main areas:

  • a live transcript sample,
  • an AI proposal queue with strict SceneCommand JSON,
  • a presenter-controlled preview and published audience map.

The planner proposes small typed commands such as add_node, connect_nodes, and highlight. Each command is validated before it reaches the review queue. The presenter can approve, reject, undo, or reset. Only approved changes update the audience map.

The submitted demo is English-first for judging, while the underlying fixture and transcript path still support Japanese and multilingual input.

How We Built It

The project is a TypeScript monorepo with a deliberately narrow AI boundary:

  • packages/contracts defines Zod schemas for transcript chunks, scene models, scene commands, presenter decisions, and session artifacts.
  • packages/planner contains the deterministic fixture planner and the optional GPT-5.6 Responses API adapter.
  • packages/scene-engine applies proposal preview, approval, rejection, undo/redo, freeze, and audience-state transitions.
  • apps/server exposes the loopback judge demo API.
  • apps/web renders the dependency-free one-screen presenter/audience UI.

With OPENAI_API_KEY, the server uses gpt-5.6-terra by default through the Responses API with store: false, low reasoning effort, and a strict JSON Schema. Without a key, the same UI automatically uses a deterministic fixture planner so judges can run the complete approval flow without secrets.

Core implementation was built with Codex using GPT-5.6 Sol as the development-time engineering agent. Codex inspected the existing contracts, implemented the planner/server/UI slice, added safety tests, updated the submission narrative, and ran the verification gate. Codex is not embedded in the runtime.

Challenges We Ran Into

The hardest part was resisting the tempting version of the idea. A fully realtime meeting copilot could easily become a vague demo where the model appears to "understand" a conversation but the safety boundary is unclear.

We kept the scope smaller:

  • model output must cross a typed SceneCommand boundary,
  • structured output is followed by application-side Zod validation,
  • every cited source segment must exist in the transcript,
  • AI proposals never publish directly,
  • keyless judging must work without API credentials.

That constraint made the demo more practical and easier to judge.

Accomplishments

  • Built a one-screen judge demo that clearly separates transcript, proposal queue, presenter approval, and published audience state.
  • Added a server-side GPT-5.6 planner boundary while preserving a deterministic no-key demo path.
  • Implemented approve, reject, undo, and reset flows.
  • Added fail-closed behavior for invalid JSON, schema mismatch, unknown source IDs, API failure, and unsafe input.
  • Kept API keys server-side and out of browser state, logs, tests, and artifacts.
  • Verified the project with formatting, linting, typecheck, unit tests, e2e tests, and build.

What We Learned

The most useful AI product surface was not "generate a diagram." It was the control layer around generation. The practical value comes from the typed boundary, the review queue, the visible preview, and the rule that approval is the only publishing path.

We also learned that keyless demos matter. A judge should be able to understand and replay the core product behavior even if no API key is available.

What's Next

  • Add microphone and realtime transcript ingestion.
  • Add hosted deployment, authentication, and multi-presenter sessions.
  • Improve graph layout and animation polish.
  • Persist sessions and export reviewed audience maps.
  • Connect the approved SessionArtifact boundary to existing PPTX/HTML presentation pipelines.
  • Add cost controls and production monitoring around the optional GPT-5.6 lane.

Built With

Share this project:

Updates