PeopleWorks Meeting — Co-pilot en vivo para reuniones

Co-pilot en vivo durante la reunión

El asistente IA que te acompaña mientras el equipo todavía está hablando.

¿Qué es el Co-pilot en vivo?

El Co-pilot es un asistente IA embebido en PeopleWorks Meeting al que podés consultar mientras la reunión está en curso, sin pausar la conversación ni interrumpir al equipo. A diferencia de las herramientas que actúan después del meeting (resumen, tareas, follow-up), el Co-pilot tiene acceso a la transcripción en vivo a medida que va llegando desde Whisper en chunks de ~30 segundos. La respuesta refleja lo que se acaba de decir, no lo que quedó archivado hace media hora.

Lo que podés preguntarle

¿Qué decidimos hace 5 minutos? ¿Quién quedó con la acción? Resume los últimos 10 minutos ¿Cuándo apareció el tema X? ¿Qué preguntas quedaron abiertas? Compará con la reunión del lunes

Lo que NO hace

No habla en la llamada — no hay un bot de voz interrumpiendo el flujo del equipo.
No ejecuta acciones que cambien estado sin tu OK — agendar follow-ups, crear action items y agregar decisiones se proponen, no se aplican hasta que vos confirmás.
No comparte transcripciones con nadie fuera de tu equipo — el archivo es local-first; sync a la nube solo si vos lo activaste explícitamente.

Cómo funciona por dentro

Captura local — el audio se procesa en tu dispositivo, sin bots externos en la llamada.
Transcripción chunked — Whisper transcribe el audio en chunks de ~30s y los anexa a un buffer en memoria (el LiveMeetingContext).
Splice al system prompt — cuando le preguntás algo, el Co-pilot inyecta los últimos ~4000 caracteres del buffer (≈ 5 minutos de conversación) directamente al prompt del LLM.
Tool-calling — el LLM tiene acceso a herramientas (find_relevant_notes, get_meeting_topics, get_unresolved_action_items, etc.) para consultar tu archivo de reuniones pasadas vía RAG.
Aplicación de Meeting Policy — la respuesta respeta las reglas globales que definiste en Settings (tono, longitud máxima, qué extraer siempre, reglas de privacidad).
Confirmación humana — toda acción que modifique estado se propone primero, se ejecuta solo si decís OK.

Ejemplo: pregunta en vivo

TÚ (a los 12 min de meeting): «¿Qué se decidió sobre el presupuesto Q4?»

CO-PILOT: Hace 2 minutos se aprobó +18% para data infrastructure. María lo revisa con Finance el viernes 10/05.

Tools disponibles para el Co-pilot

find_relevant_notes / find_precedent — búsqueda semántica en tus reuniones pasadas.
get_meeting_topics / get_meeting_goals / get_meeting_attendees — contexto de la reunión actual.
get_unresolved_action_items — items pendientes de meetings previos.
add_action_item / add_decision / add_open_question — propone agregar al record (con confirmación).
schedule_followup — propone agendar reunión de seguimiento.
summarize_meeting — resumen ad-hoc del meeting actual.

Privacidad y local-first

El audio nunca sale de tu dispositivo a menos que actives sync en la nube explícitamente. La transcripción se procesa localmente; solo el texto se envía al LLM API que elegiste (OpenAI, Anthropic, Google). Si tu Meeting Policy tiene una regla como «no compartir cifras financieras», el Co-pilot la omite automáticamente del resumen exportable.

Conexión con Meeting Policy: si configuraste «extraer action items con dueño + fecha», cuando le preguntás «¿qué acciones quedaron?», el Co-pilot te dirá cuáles le falta dueño o fecha y te sugerirá completarlos antes de que termine el meeting. Esa es la diferencia entre un asistente que reacciona y uno que vigila.

What is the live Co-pilot?

The Co-pilot is an AI assistant embedded in PeopleWorks Meeting that you can query while the meeting is still happening, without pausing the conversation or interrupting the team. Unlike post-meeting tools (summary, tasks, follow-up), the Co-pilot has access to the live transcript as it arrives from Whisper in ~30-second chunks. The answer it gives reflects what was just said, not what was archived half an hour ago.

What you can ask it

What did we decide 5 minutes ago? Who owns that action? Summarize the last 10 minutes When did topic X come up? What questions are still open? Compare with last Monday's meeting

What it does NOT do

Doesn't speak in the call — there's no bot voice interrupting the team's flow.
Doesn't take state-changing actions without your OK — scheduling follow-ups, creating action items and adding decisions are proposed, not executed until you confirm.
Doesn't share transcripts with anyone outside your team — the archive is local-first; cloud sync only if you explicitly enabled it.

How it works under the hood

Local capture — audio is processed on your device, no external bots in the call.
Chunked transcription — Whisper transcribes audio in ~30s chunks and appends them to an in-memory buffer (the LiveMeetingContext).
Splice into the system prompt — when you ask something, the Co-pilot injects the last ~4000 chars of the buffer (≈ 5 minutes of conversation) directly into the LLM prompt.
Tool-calling — the LLM has access to tools (find_relevant_notes, get_meeting_topics, get_unresolved_action_items, etc.) to query your past meetings archive via RAG.
Meeting Policy applied — the answer respects the global rules you set in Settings (tone, max length, what to always extract, privacy rules).
Human-in-the-loop — any state-mutating action is proposed first, executed only if you say OK.

Example: live question

YOU (12 min into the meeting): "What did we decide about the Q4 budget?"

CO-PILOT: 2 min ago, +18% was approved for data infrastructure. María reviews with Finance on Fri May 10.

Tools available to the Co-pilot

find_relevant_notes / find_precedent — semantic search across your past meetings.
get_meeting_topics / get_meeting_goals / get_meeting_attendees — context of the current meeting.
get_unresolved_action_items — items pending from earlier meetings.
add_action_item / add_decision / add_open_question — proposes adding to the record (with confirmation).
schedule_followup — proposes scheduling a follow-up meeting.
summarize_meeting — ad-hoc summary of the current meeting.

Privacy & local-first

Audio never leaves your device unless you explicitly enable cloud sync. The transcript is processed locally; only the text is sent to the LLM API of your choice (OpenAI, Anthropic, Google). If your Meeting Policy has a rule like "don't share financial figures", the Co-pilot automatically omits them from the exportable summary.

Meeting Policy connection: if you configured "extract action items with owner + due date", when you ask "what actions came up?", the Co-pilot will tell you which lack owner or date and suggest filling them in before the meeting ends. That's the difference between an assistant that reacts and one that watches over you.

Live mind map

Decisiones, acciones y preguntas que aparecen mientras el equipo conversa.

¿Qué es el live mind map?

El live mind map es la vista visual de lo que la reunión va produciendo mientras todavía está viva: conceptos, decisiones, action items, preguntas inteligentes y preguntas abiertas. No es un dibujo decorativo ni un resumen post-mortem. Sale del mismo stream que alimenta al Co-pilot: Whisper entrega chunks, LiveMeetingContext conserva el buffer actual, y RealtimeAssistantService analiza cada fragmento para convertir conversación desordenada en estructura navegable.

Qué aparece en el mapa

Decisiones tomadas Action items con dueño Preguntas abiertas Conceptos técnicos Temas recurrentes Archivos citados por RAG

Lo que NO hace

No reemplaza la transcripción — el mapa es una capa de lectura rápida; el texto completo sigue guardado como fuente.
No inventa nodos para llenar pantalla — si un chunk no trae decisiones, preguntas o conceptos útiles, el insight puede quedar vacío.
No confirma tareas por vos — puede detectar "María revisa pricing", pero crear un item formal sigue pasando por confirmación humana.

Cómo funciona por dentro

Chunk entrante — ChunkedTranscriptionService emite un TranscriptionUpdate con NewChunk, FullTranscript, ChunkIndex y timestamp.
Buffer vivo — MeetingWorkspace anexa el update a LiveMeetingContext, así el Co-pilot y el mapa leen el mismo ahora.
Análisis incremental — RealtimeAssistantService.AnalyzeStreamAsync procesa cada chunk y pide JSON estricto con concepts, questions, actionItems, decisions y openQuestions.
Contexto RAG opcional — si hay tools de insight, el modelo puede llamar find_relevant_notes, find_precedent o get_meeting_topics; si no, cae a una búsqueda top-K con RagIntegrationService.FindRelevantNotesAsync.
Estructura visual — MindmapGeneratorService puede generar el árbol completo desde la transcripción, calcular layout Radial, Tree o Force, y exportar JSON/SVG.
Persistencia — el resultado puede guardarse como MindmapJson junto a la nota para reabrir, comparar o exportar después.

Ejemplo: señal en vivo

EQUIPO: "Aprobamos MAUI para mobile, pero queda validar permisos de audio en Android."

MIND MAP: Decisión: .NET MAUI · Pregunta abierta: permisos Android · Acción sugerida: validar recording policy.

Privacidad y control

El mapa trabaja sobre texto ya transcripto, no sobre audio crudo compartido con terceros. Si la reunión está activa, usa una cola corta de contexto; si terminó, puede regenerarse desde la nota completa. Cuando RAG trae una referencia, el panel conserva el origen como FileReference para que puedas volver a la nota real y no confiar en memoria suelta.

Conexión con el Co-pilot: el mapa no compite con el chat. Es la superficie visual; el Co-pilot es la superficie conversacional. Si ves una pregunta abierta en el mapa, podés preguntarle "¿de dónde salió esto?" y el asistente usa el transcript tail más RAG para explicar el origen.

What is the live mind map?

The live mind map is the visual layer of what the meeting is producing while it is still in motion: concepts, decisions, action items, smart questions, and unresolved questions. It is not a decorative graph or a post-meeting summary. It comes from the same stream that feeds the Co-pilot: Whisper delivers chunks, LiveMeetingContext keeps the current buffer, and RealtimeAssistantService analyzes each fragment so loose conversation becomes navigable structure.

What shows up on the map

Decisions made Action items with owners Open questions Technical concepts Recurring topics RAG-cited files

What it does NOT do

Doesn't replace the transcript — the map is a fast-reading layer; the full text remains the source of truth.
Doesn't create filler nodes — if a chunk has no useful decisions, questions, or concepts, the insight can be empty.
Doesn't confirm tasks for you — it can detect "Maria reviews pricing", but creating the formal item still requires human confirmation.

How it works under the hood

Incoming chunk — ChunkedTranscriptionService emits a TranscriptionUpdate with NewChunk, FullTranscript, ChunkIndex, and timestamp.
Live buffer — MeetingWorkspace appends the update to LiveMeetingContext, so the Co-pilot and the map read the same now.
Incremental analysis — RealtimeAssistantService.AnalyzeStreamAsync processes each chunk and asks for strict JSON with concepts, questions, actionItems, decisions, and openQuestions.
Optional RAG context — with insight tools available, the model can call find_relevant_notes, find_precedent, or get_meeting_topics; otherwise it falls back to top-K search through RagIntegrationService.FindRelevantNotesAsync.
Visual structure — MindmapGeneratorService can generate the full tree from the transcript, calculate Radial, Tree, or Force layout, and export JSON/SVG.
Persistence — the result can be stored as MindmapJson with the note, then reopened, compared, or exported later.

Example: live signal

TEAM: "We approved MAUI for mobile, but Android audio permissions still need validation."

MIND MAP: Decision: .NET MAUI · Open question: Android permissions · Suggested action: validate recording policy.

Privacy and control

The map works over already-transcribed text, not raw audio shared with third parties. While the meeting is active, it uses a short context tail; after the meeting ends, it can be regenerated from the full note. When RAG returns a reference, the panel keeps the source as a FileReference so you can jump back to the real note instead of trusting loose memory.

Co-pilot connection: the map does not compete with chat. It is the visual surface; the Co-pilot is the conversational surface. If you see an open question on the map, ask "where did this come from?" and the assistant uses the transcript tail plus RAG to explain the origin.

Whisper en chunks + 125+ idiomas

Transcripción local en chunks de ~30 segundos para que el Co-pilot vea el ahora.

¿Qué es Whisper en chunks?

Es la forma en que PeopleWorks Meeting convierte audio en texto usable durante la reunión, no recién al final. WhisperTranscriptionService habla con la API de Whisper para transcribir archivos de audio; ChunkedTranscriptionService lo vuelve realtime practical: graba ventanas cortas, las manda a transcribir, borra el archivo temporal y emite un update. El default está pensado en ~30 segundos porque equilibra latencia, costo y calidad. Ese ritmo también le da al usuario una expectativa simple: cada medio minuto aparecen señales nuevas, sin fingir simultaneidad absoluta.

Qué habilita

Co-pilot con contexto actual Mind map en vivo Buffer acumulado Language auto-detect 125+ idiomas Whisper Post-proceso al detener

Lo que NO hace

No mete un bot en la llamada — la captura ocurre en tu dispositivo y rota sub-grabaciones locales.
No promete streaming palabra por palabra — el sistema entrega chunks completos; eso evita UI nerviosa y reduce errores de contexto.
No sube archivos gigantes — WhisperTranscriptionService corta en 25MB y valida extensiones soportadas antes de llamar a la API.

Cómo funciona por dentro

Opciones explícitas — ChunkedTranscriptionOptions define Language, ChunkSeconds, SampleRate y SessionId; el default es es, 30s y 16 kHz.
Rotación cross-platform — en cada ciclo, el recorder arranca una sub-grabación WAV con realtime desactivado para evitar buffers nativos por plataforma.
Transcripción robusta — TranscribeFileAsync valida .m4a, .mp3, .wav, .webm, .mp4, .mpeg y .mpga, usa response_format=verbose_json y temperature=0.
Reintentos — errores 429/5xx tienen retry con backoff; auth inválida y payload demasiado grande fallan con mensaje claro.
Update acumulado — cada resultado produce TranscriptionUpdate: texto nuevo, transcript completo, índice de chunk y hora UTC.
Consumo en vivo — MeetingWorkspace alimenta al assistant channel y a LiveMeetingContext; después el chat inyecta los últimos ~4000 caracteres en el prompt.

Ejemplo: latencia útil

AUDIO: minuto 08:00 a 08:30, discusión sobre renovar contrato enterprise.

WHISPER: chunk #16 transcripto · Co-pilot ya puede responder "¿qué se acaba de decidir?".

Privacidad, idioma y límites

La API key se resuelve primero desde SecureStorage (OpenAIApiKey) y después desde AppSettings.json. Si pasás language="auto", Whisper detecta idioma; si no, PeopleWorks manda el tag BCP-47 que eligió el usuario. La transcripción local-first significa que el archivo temporal vive solo lo necesario para transcribirse y luego se elimina. Si una llamada falla, el meeting no queda bloqueado: se registra el error, se sigue con el próximo chunk y el usuario conserva el audio/transcript que sí entró.

Por qué chunks y no batch: batch al final es más simple, pero deja ciegos al Co-pilot y al mind map durante la reunión. Los chunks le dan memoria reciente sin esperar una hora de audio.

What is chunked Whisper?

It is how PeopleWorks Meeting turns audio into usable text during the meeting, not only after it ends. WhisperTranscriptionService calls the Whisper API to transcribe audio files; ChunkedTranscriptionService makes it practical in realtime: it records short windows, sends them for transcription, deletes the temporary file, and emits an update. The default is tuned around ~30 seconds because it balances latency, cost, and quality. That cadence also gives users a clear expectation: new signals arrive about twice a minute, without pretending to be absolute word-level streaming.

What it enables

Co-pilot with current context Live mind map Running buffer Language auto-detect 125+ Whisper languages Post-process on stop

What it does NOT do

Doesn't add a bot to the call — capture happens on your device and rotates local sub-recordings.
Doesn't promise word-by-word streaming — the system emits complete chunks; that keeps the UI calmer and reduces context errors.
Doesn't upload oversized files — WhisperTranscriptionService enforces the 25MB limit and validates supported extensions before calling the API.

How it works under the hood

Explicit options — ChunkedTranscriptionOptions defines Language, ChunkSeconds, SampleRate, and SessionId; defaults are es, 30s, and 16 kHz.
Cross-platform rotation — each cycle starts a WAV sub-recording with realtime transcription disabled, avoiding native per-platform buffer hooks.
Robust transcription — TranscribeFileAsync validates .m4a, .mp3, .wav, .webm, .mp4, .mpeg, and .mpga, then uses response_format=verbose_json and temperature=0.
Retries — 429/5xx errors retry with backoff; invalid auth and oversized payloads fail with clear messages.
Cumulative update — each result produces a TranscriptionUpdate: new text, full transcript, chunk index, and UTC time.
Live consumption — MeetingWorkspace feeds the assistant channel and LiveMeetingContext; later the chat injects the last ~4000 characters into the prompt.

Example: useful latency

AUDIO: minute 08:00 to 08:30, discussion about renewing an enterprise contract.

WHISPER: chunk #16 transcribed · Co-pilot can now answer "what did we just decide?".

Privacy, language, and limits

The API key is resolved first from SecureStorage (OpenAIApiKey) and then from AppSettings.json. If you pass language="auto", Whisper detects the language; otherwise PeopleWorks sends the BCP-47 tag selected by the user. Local-first transcription means the temporary file exists only as long as needed for transcription, then gets deleted. If one call fails, the meeting is not blocked: the error is logged, the next chunk continues, and the user keeps the audio/transcript that did arrive.

Why chunks instead of batch: end-of-meeting batch processing is simpler, but it leaves the Co-pilot and mind map blind during the meeting. Chunks give them recent memory without waiting for an hour of audio.

Memoria de reuniones pasadas (RAG)

Búsqueda semántica sobre tu propio archivo de meetings.

¿Qué es la memoria RAG?

La memoria RAG es la forma en que PeopleWorks Meeting consulta reuniones pasadas sin meter toda tu historia en el prompt. RagIntegrationService genera embeddings para notas y transcripciones, busca los fragmentos más parecidos a tu pregunta y devuelve contexto corto para que el Co-pilot conteste con fuente. Es memoria semántica: si preguntás por "renovación enterprise", puede encontrar una nota que decía "contrato anual B2B" aunque no use las mismas palabras. La gracia es precisión con límite: traer lo necesario, no reabrir todo el archivo.

Qué podés recuperar

Decisiones previas Precedentes Action items pendientes Context files Transcripciones largas Reuniones por proyecto

Lo que NO hace

No reemplaza permisos — si una nota no está disponible para tu usuario o proyecto, no debería aparecer como contexto.
No manda todo el archivo al modelo — primero busca por embeddings y pasa snippets relevantes, no el histórico completo.
No oculta falta de evidencia — si no encuentra notas relevantes, QueryWithContextAsync lo declara y puede responder de forma general.

Cómo funciona por dentro

Ingesta — al terminar una reunión, la transcripción se guarda en la nota y puede subirse vía UploadTranscriptionAsync a /ResourceFile/uploadlongtext o indexarse localmente.
Embeddings locales — GenerateAndStoreEmbeddingsAsync usa text-embedding-3-small y guarda un NoteEmbedding con NoteId, vector y fecha.
Búsqueda semántica — FindRelevantNotesAsync genera embedding de la query, calcula similitud coseno y ordena top-K con threshold 0.3.
Filtros por tag — cuando aplica, requireTag limita resultados a tags tipo meeting:42, project:7 o context.
Tool-calling — el Co-pilot puede llamar find_relevant_notes, find_precedent, find_relevant_context_files, search_transcript o compare_meetings.
Respuesta grounded — QueryWithContextAsync arma un prompt que dice "answer based ONLY on the context" y adjunta títulos, snippets y source notes.

Ejemplo: memoria útil

TÚ: "¿Ya habíamos definido el owner de migración SSO?"

RAG: Encontré "Security Sync - 03/04": Diego quedó como owner, con revisión de Legal antes del piloto.

Privacidad y fallback

PeopleWorks soporta dos caminos: RAG externo de PeopleWorks Copilot, con IPeopleWorksCopilotApi y token Bearer, o RAG local con embeddings en la base de datos de la app. La key se carga desde Settings/AppSettings, y si no hay configuración válida la app sigue funcionando offline: grabás, transcribís y guardás; simplemente no hay búsqueda semántica remota. Las fallas de RAG son no fatales para la reunión: se loguean y el Co-pilot vuelve al contexto disponible.

Conexión con reuniones activas: RAG no sustituye al LiveMeetingContext. El live buffer contesta "qué acaba de pasar"; RAG contesta "qué pasó antes". El Co-pilot mezcla ambos cuando la pregunta necesita presente y pasado.

What is RAG memory?

RAG memory is how PeopleWorks Meeting looks up past meetings without stuffing your whole history into the prompt. RagIntegrationService generates embeddings for notes and transcripts, searches for the fragments closest to your question, and returns compact context so the Co-pilot can answer with a source. It is semantic memory: if you ask about "enterprise renewal", it can find a note that said "annual B2B contract" even if the words do not match exactly. The point is precision with boundaries: retrieve what matters, not reopen the whole archive.

What you can retrieve

Past decisions Precedents Pending action items Context files Long transcripts Project meetings

What it does NOT do

Doesn't bypass permissions — if a note is not available to your user or project, it should not appear as context.
Doesn't send the whole archive to the model — it searches embeddings first and passes relevant snippets, not full history.
Doesn't hide missing evidence — if no relevant notes are found, QueryWithContextAsync says so and can provide a general answer.

How it works under the hood

Ingestion — when a meeting ends, the transcript is saved on the note and can be uploaded through UploadTranscriptionAsync to /ResourceFile/uploadlongtext or indexed locally.
Local embeddings — GenerateAndStoreEmbeddingsAsync uses text-embedding-3-small and stores a NoteEmbedding with NoteId, vector, and generated date.
Semantic search — FindRelevantNotesAsync embeds the query, calculates cosine similarity, and orders top-K results with a 0.3 threshold.
Tag filters — when relevant, requireTag restricts results to tags such as meeting:42, project:7, or context.
Tool-calling — the Co-pilot can call find_relevant_notes, find_precedent, find_relevant_context_files, search_transcript, or compare_meetings.
Grounded answer — QueryWithContextAsync builds a prompt that says "answer based ONLY on the context" and attaches titles, snippets, and source notes.

Example: useful memory

YOU: "Had we already assigned the SSO migration owner?"

RAG: Found "Security Sync - 04/03": Diego owns it, with Legal review before the pilot.

Privacy and fallback

PeopleWorks supports two paths: external PeopleWorks Copilot RAG, with IPeopleWorksCopilotApi and Bearer token, or local RAG with embeddings in the app database. The key is loaded from Settings/AppSettings, and if no valid configuration exists the app still works offline: you can record, transcribe, and save; remote semantic search is simply unavailable. RAG failures are non-fatal for the meeting: they are logged and the Co-pilot falls back to the context it still has.

Active meeting connection: RAG does not replace LiveMeetingContext. The live buffer answers "what just happened"; RAG answers "what happened before". The Co-pilot combines both when a question needs present and past.

Meeting Policy global

Reglas que se aplican automáticamente a toda reunión.

¿Qué es la Meeting Policy?

La Meeting Policy es un conjunto de reglas globales que se aplican automáticamente a toda reunión, sin que tengas que invocarlas ni activarlas cada vez. La definís una sola vez en Settings → "Meeting Policy" y queda activa para todos los meetings futuros. Es el contrapunto de las Skills — que se invocan a demanda vía Command Palette —: la Policy está siempre presente, como un contrato silencioso entre vos y el Co-pilot. Definís el tono, qué extraer siempre, cuánto detalle querés en los resúmenes y qué reglas de privacidad se aplican. El Co-pilot lo respeta incluso durante la reunión activa, no solo en el resumen post-meeting.

Los 8 campos de la Policy

Tone: formal · balanced · casual · executive MaxSummaryBullets: 3..10 ExtractDecisions: bool ExtractActionItems: bool ExtractOpenQuestions: bool RequireOwnerAndDate: bool CopilotProactivity: silent · balanced · proactive PrivacyNote: texto libre

Lo que NO es

No es un workflow programable: no podés definir reglas condicionales del tipo "si el meeting es con clientes, usá tone formal". Eso pertenece a las Skills, que son invocables y contextuales, y están en fase futura.
No reemplaza el criterio humano: la Policy guía el comportamiento del Co-pilot pero no bloquea acciones — si pedís algo explícitamente, el Co-pilot responde aunque no matchee la Policy al 100%.
No es por meeting individual: es global. Si necesitás reglas distintas para distintos tipos de reunión, eso será parte de las Skills cuando llegue esa fase.

Cómo se aplica — el pipeline técnico

Definición — configurás los 8 campos desde Settings → "Meeting Policy" en mobile o web. Se persisten individualmente vía Preferences con el prefijo pw_meeting.* en AppSettingsHelper.cs.
Construcción del prompt — cada vez que le preguntás algo al Co-pilot, ChatService.BuildSystemPrompt arma el system prompt completo. Inserta un bloque === MEETING POLICY (always-applied) === con todos los campos configurados.
Inyección pre-transcript — el bloque Policy se coloca antes del transcript vivo (LiveMeetingContext), así el LLM lo trata como contrato fundacional, no como sugerencia tardía.
Aplicación en runtime — el LLM respeta tone, max bullets, campos a extraer y reglas de privacidad en cada respuesta. RequireOwnerAndDate fuerza al Co-pilot a pedir dueño+fecha cuando detecta un action item incompleto.
Honor de PrivacyNote — el texto libre que pusiste (ej. "no incluir cifras financieras en exports") se inyecta literal en el prompt y el LLM lo trata como regla de omisión.

Ejemplo: misma pregunta, distinta Policy

TÚ: «Resumime la reunión.»

Policy: executive + MaxSummaryBullets=3: 3 bullets ejecutivos. Sin detalles operativos. Estilo CEO-ready.

Policy: casual + MaxSummaryBullets=8 + PrivacyNote="sin cifras": 8 bullets detallados en tono cercano. Omite montos financieros aunque se hayan mencionado.

Multi-tenant safe

Hoy la Policy es per-device del usuario — cada dispositivo tiene su propia configuración local vía Preferences. Cuando el SaaS multi-tenant llegue, la Policy migrará a ser per-tenant: un admin definirá reglas corporativas (ej. "toda reunión del tenant X extrae decisions y action items con dueño+fecha"), y los usuarios individuales heredarán esa base. La arquitectura de BuildSystemPrompt ya está preparada para recibir un bloque === TENANT POLICY (org-wide) === adicional sin cambios estructurales.

Conexión con el Co-pilot live: la Policy no es solo para el resumen post-meeting. El Co-pilot la aplica en cada respuesta durante la reunión activa. Si configuraste CopilotProactivity=proactive, el Co-pilot puede intervenir sin que le preguntes — por ejemplo, avisarte cuando detecta que un action item se mencionó pero no se asignó dueño. Esa es la diferencia entre un asistente que reacciona y uno que vigila.

What is the Meeting Policy?

The Meeting Policy is a set of global rules that are automatically applied to every meeting — you don't invoke them per session. Define them once in Settings → "Meeting Policy" and they stay active for all future meetings. It's the counterpart to Skills (which are invoked on-demand via Command Palette): the Policy is always on, like a silent contract between you and the Co-pilot. You set the tone, what to always extract, how much detail you want in summaries, and what privacy rules apply. The Co-pilot honors it even during the active meeting, not just in the post-meeting summary.

The 8 Policy fields

What it does NOT do

Not a programmable workflow: you can't define conditional rules like "if the meeting is with clients, use formal tone". That belongs to Skills, which are contextual and invokeable, and are a future phase.
Doesn't override human judgment: the Policy guides the Co-pilot but doesn't block actions — if you explicitly ask for something, the Co-pilot responds even if it doesn't match the Policy 100%.
Not per-meeting: it's global. Different rules for different meeting types will be part of future Skills.

How it's applied — the technical pipeline

Definition — you configure the 8 fields from Settings → "Meeting Policy" on mobile or web. They're persisted individually via Preferences with the pw_meeting.* prefix in AppSettingsHelper.cs.
Prompt construction — every time you ask the Co-pilot something, ChatService.BuildSystemPrompt assembles the full system prompt. It inserts a === MEETING POLICY (always-applied) === block with all configured fields.
Pre-transcript injection — the Policy block is placed before the live transcript (LiveMeetingContext), so the LLM treats it as a founding contract, not a late suggestion.
Runtime enforcement — the LLM respects tone, max bullets, extraction fields, and privacy rules in every response. RequireOwnerAndDate forces the Co-pilot to ask for owner+date when it detects an incomplete action item.
PrivacyNote honored — the free text you entered (e.g. "don't include financial figures in exports") is injected verbatim into the prompt and the LLM treats it as an omission rule.

Example: same question, different Policy

YOU: "Summarize the meeting."

Policy: executive + MaxSummaryBullets=3: 3 executive bullets. No operational detail. CEO-ready style.

Policy: casual + MaxSummaryBullets=8 + PrivacyNote="no figures": 8 detailed bullets in a conversational tone. Financial amounts omitted even if discussed.

Multi-tenant safe

Today the Policy is per-device — each device has its own local config via Preferences. When the multi-tenant SaaS arrives, the Policy will migrate to per-tenant: an admin will define org-wide rules (e.g. "every meeting in tenant X extracts decisions and action items with owner+date"), and individual users will inherit that baseline. The BuildSystemPrompt architecture is already designed to accept an additional === TENANT POLICY (org-wide) === block with zero structural changes.

Co-pilot live connection: the Policy isn't just for post-meeting summaries. The Co-pilot applies it to every response during the active meeting. If you set CopilotProactivity=proactive, the Co-pilot can intervene without being asked — for example, alerting you when it detects an action item was mentioned but no owner was assigned. That's the difference between an assistant that responds and one that watches over you.

Local-first, sin bots, 6 idiomas

El audio se procesa en tu dispositivo. Sin bots externos en la llamada.

¿Por qué local-first?

PeopleWorks Meeting se diseñó desde el día cero con una premisa: tu audio es tuyo. A diferencia de Granola.ai u Otter.ai — que son cloud-first y requieren que el audio viaje a sus servidores —, nosotros procesamos todo en tu dispositivo. La captura de audio, la transcripción vía Whisper y la búsqueda RAG corren localmente. Esto no es un feature de privacidad accesorio: es la decisión arquitectónica fundacional del producto. El resultado es que podés grabar una reunión confidencial — una negociación, un board meeting, una sesión de terapia — con la certeza de que el audio crudo nunca salió de tu máquina. Lo único que viaja es el texto que vos elegís mandar al LLM de tu preferencia (OpenAI, Anthropic, Google). Y si no querés que viaje nada, también podés: la app funciona completamente offline para grabar, transcribir localmente y consultar tu archivo.

Los pilares

Audio procesado en dispositivo RAG con embeddings locales Sync a la nube opcional Sin bots en la llamada 6 idiomas de UI 125+ idiomas de transcripción

Lo que NO es

No es offline-only: podés sincronizar tus meetings entre dispositivos vía PeopleWorks.Api cuando quieras. El local-first no te aísla; te da control sobre cuándo y qué compartir.
No es self-hosted complicado: no necesitás montar un servidor ni configurar Docker. El local-first es transparente: abrís la app, grabás, y funciona. El sync es un botón, no un requisito.
No es "modo avión" permanente: las funciones que requieren LLM (Co-pilot, RAG avanzado, mind map) necesitan conexión porque llaman a APIs externas. Pero la grabación, la transcripción base y el almacenamiento son 100% locales.

Cómo funciona por dentro — la frontera de privacidad

Audio — capturado por AudioRecordingService en iOS/Android/Windows/Mac. Se guarda como buffer en memoria y archivo temporal local. Nunca sale del dispositivo.
Transcripción — ChunkedTranscriptionService corta el audio en chunks de ~30s y los envía uno por uno a la API de Whisper. Solo el chunk de audio viaja; se descarta apenas llega la respuesta. El texto transcripto se acumula en LiveMeetingContext.
Embeddings — según configuración, se generan localmente (on-device) o vía OpenAI embeddings API. Si elegís local, los vectores nunca salen. Si usás API, solo el texto del chunk viaja, no el audio.
RAG — busca en EmbeddingEntity almacenado en SQLite local usando cosine similarity. Top-K resultados se inyectan como contexto al LLM. La búsqueda es enteramente local; solo el prompt final (texto) va al LLM.
Sync (opcional) — si activás sync, el texto de tus meetings se sincroniza con tu tenant privado en PeopleWorks.Api. Tus datos no se comparten con otros usuarios ni tenants.
UI — los 6 idiomas de interfaz se cargan de wwwroot/i18n/{lang}.json embebidos como recursos. Dates, settings, mensajes del sistema y prompts del LLM están localizados.

Ejemplo: reunión confidencial

MAESTRO: Graba un board meeting confidencial en su Mac.

SISTEMA: Audio → buffer local · Whisper transcribe en chunks · transcripción queda en SQLite local.

MAESTRO: «Co-pilot, ¿qué aprobó el board sobre la ronda B?»

CO-PILOT: Responde con lo transcripto. Solo el texto de la pregunta + contexto relevante viajó al LLM API que el Maestro configuró. El audio crudo nunca existió fuera de su Mac.

MAESTRO: Al terminar, borra el meeting completo. Cero rastro en cualquier servidor.

Qué dato sale del dispositivo — tabla de privacidad

Feature	¿Sale del device?	¿A dónde?
Audio crudo	Nunca	—
Chunks de audio (transcripción)	Sí, efímero	Whisper API (OpenAI) — se descartan al recibir respuesta
Texto transcripto	Solo al LLM elegido	OpenAI / Anthropic / Google (configurable)
Embeddings	Opcional	Embedding API o generación local (configurable)
Sync (notas, meetings)	Opcional	Tu tenant privado en PeopleWorks.Api

Conexión con Meeting Policy: la Policy incluye el campo PrivacyNote, que te permite agregar reglas adicionales que el Co-pilot honra incluso cuando el texto viaja al LLM. Por ejemplo, si ponés "no incluir nombres de clientes externos en el resumen export", el Co-pilot los omite automáticamente. El local-first protege el audio; la Policy protege el texto.

Why local-first?

PeopleWorks Meeting was designed from day zero with a single premise: your audio is yours. Unlike Granola.ai or Otter.ai — which are cloud-first and require audio to travel to their servers — we process everything on your device. Audio capture, Whisper transcription, and RAG search all run locally. This isn't a nice-to-have privacy feature: it's the foundational architectural decision of the product. The result: you can record a confidential meeting — a negotiation, a board session, a therapy call — knowing the raw audio never left your machine. The only thing that leaves is the text you choose to send to the LLM of your preference (OpenAI, Anthropic, Google). And if you don't want anything to leave, that works too: the app is fully functional offline for recording, transcribing locally, and searching your archive.

The pillars

Audio processed on-device RAG with local embeddings Optional cloud sync No bots in the call 6 UI languages 125+ transcription languages

What it does NOT do

Not offline-only: you can sync your meetings across devices via PeopleWorks.Api whenever you choose. Local-first doesn't isolate you; it gives you control over when and what to share.
Not complex self-hosting: no server to set up, no Docker to configure. Local-first is transparent: open the app, record, and it works. Sync is a button, not a requirement.
Not permanent airplane mode: features that need an LLM (Co-pilot, advanced RAG, mind map) require connectivity because they call external APIs. But recording, base transcription, and storage are 100% local.

How it works — the privacy boundary

Audio — captured by AudioRecordingService on iOS/Android/Windows/Mac. Stored as an in-memory buffer and a local temp file. Never leaves the device.
Transcription — ChunkedTranscriptionService slices audio into ~30s chunks and sends them one by one to the Whisper API. Only the audio chunk travels; it's discarded the moment the response arrives. Transcribed text accumulates in LiveMeetingContext.
Embeddings — depending on your config, generated locally (on-device) or via the OpenAI embeddings API. If local, vectors never leave. If API, only the chunk text travels, never the audio.
RAG — searches EmbeddingEntity stored in local SQLite using cosine similarity. Top-K results are injected as context into the LLM prompt. The search is entirely local; only the final prompt (text) goes to the LLM.
Sync (optional) — if you enable sync, your meeting text syncs with your private tenant on PeopleWorks.Api. Your data is never shared with other users or tenants.
UI — the 6 interface languages are loaded from wwwroot/i18n/{lang}.json embedded as resources. Dates, settings, system messages, and LLM prompts are all localized.

Example: confidential meeting

USER: Records a confidential board meeting on their Mac.

SYSTEM: Audio → local buffer · Whisper transcribes in chunks · transcript stays in local SQLite.

USER: "Co-pilot, what did the board approve about the Series B?"

CO-PILOT: Answers from the transcript. Only the question text + relevant context traveled to the LLM API the user configured. Raw audio never existed outside their Mac.

USER: After the meeting, deletes it entirely. Zero trace on any server.

What data leaves the device — privacy table

Feature	Leaves the device?	Destination
Raw audio	Never	—
Audio chunks (transcription)	Yes, ephemeral	Whisper API (OpenAI) — discarded on response
Transcribed text	Only to chosen LLM	OpenAI / Anthropic / Google (configurable)
Embeddings	Optional	Embedding API or local generation (configurable)
Sync (notes, meetings)	Optional	Your private tenant on PeopleWorks.Api

Meeting Policy connection: the Policy includes the PrivacyNote field, which lets you add extra rules the Co-pilot honors even when text travels to the LLM. For example, if you enter "don't include external client names in the exported summary", the Co-pilot automatically omits them. Local-first protects the audio; the Policy protects the text.

De Meta a Logro con IA

Lo que el Co-pilot hace por tu reunión

Co-pilot en vivo durante la reunión

Live mind map

Whisper en chunks + 125+ idiomas

Memoria de reuniones pasadas (RAG)

Meeting Policy global

Local-first, sin bots, 6 idiomas

Experimenta el Poder de la IA

💡 Preguntas sugeridas:

Tu Compañero en Cada Contexto

Reflexión Personal y Autoanálisis

Reuniones Corporativas Inteligentes

Educación Potenciada por IA

Coaching & Crecimiento Personal