Lecture Synthesis Engine

Project name

Lecture Synthesis Engine

Elevator pitch (one-liner)

An agent that turns recorded lectures into study notes, and stops to ask you instead of guessing when the lecture contradicts itself.

What it does

Students record lectures and feed the transcripts to AI summarizers. Every summarizer has the same quiet failure: when the transcript contradicts itself, the model picks the most plausible reading and smooths the rest away. The student never knows. The error goes into the notes, and from there onto the exam.

The Lecture Synthesis Engine inverts that instinct. It ingests a raw lecture transcript (recorded on a Plaud device), runs a mandatory hostile audit of the whole text before formatting anything, and produces clean, hierarchical study notes in Markmap-compatible markdown. When the audit finds a critical academic conflict - a drug mechanism stated two ways, a Gram-stain result contradicting the described morphology, a statistical conclusion that flips between segments - the agent halts mid-run, asks the student one sharp question with both excerpts quoted verbatim, waits for the answer, and only then continues. The resolution is recorded inline in the notes. Small stuff (typos, garbled filler, one-off phrasing) never halts the run; it lands in a "verify later" section.

Who it's for

Any student who records lectures and studies from transcripts. It was built by one, during his own exam week, and dogfooded on his real Microbiology, Pharmacology, and Biostatistics lectures. On the first clean run against a real lecture, the engine halted on a Gram-stain contradiction the professor actually made - the exact error a normal summarizer would have silently "fixed."

Why it matters

The failure this fixes is invisible by design: a summarizer that guesses never announces the guess, so the student finds out at the exam, if ever. Every student with a recorder app already produces the raw input daily - no behavior change, no new workflow, the engine just stops the one class of error no student can catch by reading the output. That is the whole bet of the Everyday Agents track: an agent that does the repetitive work in the background and surfaces only for the decision that actually needs a human. "Your own lecture disagrees with itself" is exactly that decision.

How it works

The engine is a Strands Agents SDK agent driven by an "adversarial auditor" system prompt whose cardinal rule is: never silently resolve a contradiction.

• Pass 1 - AUDIT (mandatory, isolated). The agent reads the full transcript and actively hunts for conflicts, working entirely inside <audit_scratchpad> tags so no reasoning can leak into the final output.
• The halt is a tool call, not text. When a critical conflict exists, the agent invokes a human-in-the-loop tool implemented with the Strands SDK. The tool pauses the run and presents a phone-friendly question: the conflict in one plain sentence, the conflicting excerpts quoted verbatim with locations, the likely options (A / B), and one ask: which is correct? Binding the halt to an explicit tool call is what makes the pause structural; a model asked to "wait" in plain text just keeps going.
• Pass 2 - FORMAT. Only after the audit clears (or every halt is resolved) does the agent format the notes: hierarchical Markmap nodes for concepts, mechanisms, definitions, and formulas, plus the "verify later" section. The output is stripped of scratchpad content as defense in depth.

Development runs use the Gemini API; the agent is model-interchangeable through Strands, and the deployment target is Claude on Amazon Bedrock.

What we learned

The interesting engineering problem was not summarization; it was making an agent that knows when not to proceed. That took three deliberate mechanisms: an audit pass that is mandatory and runs before any formatting, a scratchpad quarantine so audit reasoning cannot contaminate output, and a halt bound to a real SDK tool call so the agent physically cannot continue without a human answer. We validated the cage by sabotage: planting a Gram-positive/Gram-negative contradiction in a real transcript made the run halt and quote both planted lines back verbatim. Then the clean, unsabotaged run halted too, on a genuine contradiction the professor made in class. The tool works on the failure it was built for, and it works on the failures nobody planted.

Built with

Strands Agents SDK (human-in-the-loop tool), Python, Gemini API (development), Amazon Bedrock (deployment target), Plaud transcript exports, Markmap.

Try it / links

• License: MIT (in repo)

Built With

• amazon-bedrock
• education
• google-gemini
• markmap
• plaud
• python
• strands-agents