Added multi-speaker diarization and shared notebooks. It feels like a team memory — searchable and privacy-aware.

When we launched Quietscribe v3, I wanted this to feel less like a solo tool and more like a collective memory engine for teams. The switch to multi-speaker diarization meant you don’t just get a transcript of “what was said,” you get who said it, when they said it, and what actions followed. Combine that with shared notebooks, searchable archives, and privacy-by-default access controls, and you’ve built something that supports teams remembering their story, not just remembering words.

Why multi-speaker matters

In most meeting-transcript tools I’ve used, it’s single-voice, flat text. But when you work in teams doing design workshops, post-mortems, customer calls, you need diarization (“Alice said the API, Bob replied…”), segmentation, tagging and context. In research, diarization models are now using memory-aware multi-speaker embeddings to handle complex speech overlaps and real-world noise. arxiv.org+2arxiv.org+2 That’s the tech foundation we tapped into.

For Quietscribe v3 this meant:

  • Each speaker gets a consistent label across sessions and notebooks.

  • Shared notebooks tie transcripts, tasks and follow-ups together.

  • Search becomes “show me all sessions where Bob talked about WebRTC and we flagged an action” rather than “show me all content with WebRTC.”

  • Privacy-centric design: teams only access sessions relevant to them; transcripts are encrypted at rest if required.

How we built it (at a glance)

Here’s a little sample of how the flow works:

 

// Client: record session
const recording = await startRecording();
const rawAudio = await recording.stop();

// Send audio and speaker segmentation signal to backend
const result = await fetch(“/api/transcribe-diarize”, {
method: “POST”,
body: rawAudio
});
const { transcript, speakers, segments } = await result.json();

// Store in local/shared notebook
await localDB.put(“sessions”, {
sessionId,
transcript,
speakers,
segments,
tags: [“design-workshop”,”QuietscribeV3″]
});

// Later: search UI
const hits = await index.search({
query: “WebRTC Bob action”,
filter: { teamId: myTeamId }
});

 

On the server side: minimal UI render, more indexing, diarization, encryption:

 
app.post(“/api/transcribe-diarize”, async (req, res) => {
const audio = await req.buffer();
const { transcript, speakerLabels } = await diariser.run(audio);
// save raw + metadata
await db.sessions.insert({ transcript, speakerLabels, created: new Date() });
await esClient.index({
index: “sessions”,
body: { text: transcript, speakers: speakerLabels, team: req.user.teamId }
});
res.json({ transcript, speakerLabels });
});
 

Real-world relevance & context

  • The diarization research is advancing fast: e.g., a 2025 paper exploring speaker diarization with mixture-of-experts shows how memory-aware embeddings improve performance in noisy, multi-speaker environments. arxiv.org+1

  • The shift toward team intelligence and shared memory is stronger in modern apps: rather than “my notes” you see “our team memory.” Quietscribe v3 intentionally shifts toward that.

  • Privacy and auditability matter: as teams capture discussions that feed into decisions (e.g., in enterprise/repair/engineering workflows), you need controls for who saw what and when. This maps into compliance & enterprise-workflow thinking.

What it means for you & teams

  • Searchability: Make transcripts a database of knowledge, not just files on the shelf.

  • Action integration: Link speaker turns to tasks, notes, decisions. “Bob said quote → Estimate = $5 k” becomes searchable and actionable.

  • Team flow: Instead of “I’ll remember this,” the system remembers. New joiner opens notebook and sees “Here are the last 6 sessions on this project.”

  • Privacy-first: Set up roles so repair-centre staff only see their work, insurer staff only their side; your central authority layer handles orchestration. (Sound familiar? It’s the same privacy-by-design model you used in other apps.)

Looking ahead

  • In the next phase I’m aiming for live diarization + tagging: capture meeting audio and in real-time show speaker labels, live summaries, and action-item extraction.

  • Integrate semantic notebooks: a user types “show all mentions of PWA offline from 2023” and the system pulls transcripts + tasks across all sessions.

  • Possibly embed privacy-preserving multi-speaker diarization where speaker identity is anonymised yet labelled consistently (useful for shared networks across organisations).

  • Expand into team memory graphs: nodes = sessions, people, decisions, tasks; edges = “spoke in”, “led”, “follow-up”. Makes the tool a living map of team intelligence.

Final thought

Quietscribe v3 isn’t just a “better transcription tool” — it’s a team memory platform. When you build tools that capture who, what, when for teams, you change the unit of work from “one meeting” to “all past + future meetings”. That’s where value lives. And for 2025 and beyond: that kind of tool isn’t optional. It’s expected.