Luminary.

Drie diepgangen, automatisch gekozen uit je stem.

Je start het door iets te zeggen tegen een van de stemagents — Maya, Barnaby, Consultant of Rutger. Luminary leidt de diepgang af uit de formulering en routeert daarop. Elke run is een echt, bronnengebaseerd onderzoek — geen enkele losse LLM-aanroep. Claimvalidatie over studies heen vangt tegenstrijdigheden tussen bronnen op voordat ze je bereiken. QA-anticipatie beantwoordt alvast de vervolgvragen die je waarschijnlijk gaat stellen.

Eén orchestrator, één deep pipeline, 24 met ADK gebouwde agents.

Een ElevenLabs-stemagent post naar een webhook (HMAC-geverifieerd). De research-orchestrator leidt de diepgang af, zet een plan/confirm-gate bij deep, injecteert geheugen en de knowledge graph, en geeft het door aan de deep pipeline. Studies waaieren parallel uit. Een synthese-evaluator loopt samen met een gap-analyzer rond totdat de bevindingen niet meer veranderen. Claimvalidatie vangt tegenstrijdigheden over studies heen op, QA-anticipatie beantwoordt alvast de voor de hand liggende vervolgvragen, en een mastersynthese landt het antwoord. Resultaten worden in GCS bewaard, aan de knowledge base van de agent gekoppeld voor de volgende stembeurt, en desgewenst geproduceerd als een podcast met twee presentatoren.

ElevenLabs voice agent  ──▶  webhook /webhook/elevenlabs (HMAC-verified)
                                        │
                                        ▼
                          ┌──────────────────────────┐
                          │  research_orchestrator   │
                          │  ─ depth detection       │
                          │  ─ plan/confirm gate     │
                          │  ─ memory + KG injection │
                          └──────────┬───────────────┘
                                     ▼
              ┌───────────────────────────────────────────────┐
              │                deep_pipeline                  │
              │                                               │
              │   query_analyzer ─▶ study_planner ─▶ iterative│
              │           ▼                                   │
              │   parallel(researcher × N studies)            │
              │           ▼                                   │
              │   synthesis_evaluator ─▶ gap_analyzer (loop)  │
              │           ▼                                   │
              │   claim_validator ─▶ qa_anticipator           │
              │           ▼                                   │
              │   strategic_analyst ─▶ master synthesis       │
              └───────────────────────┬───────────────────────┘
                                      ▼
                       GCS results · memory · knowledge graph
                                      ▼
                       agent KB attach  →  next voice turn
                       podcast_generator (optional, 2-host)
                       Observable dashboard (`/explore`)

Elke fase het model dat past.

Multi-provider routing is het hele punt. Geen enkel model is het juiste gereedschap voor elke fase, dus elke fase krijgt zijn eigen standaard en een fallback chain. Alles is tijdens runtime te overrulen via env vars (GEMINI_MODEL, GEMINI_PRO_MODEL, OPENAI_REASONING_MODEL).

De niet voor de hand liggende keuzes die bepalen wat het kan.

Plan/confirm-gate vóór deep runs

Deep-modus heeft een budget van 60 minuten. Luminary bouwt eerst het studieplan, leest het via spraak terug ter bevestiging, en voert het pas daarna uit. AUTO_PROCEED_* env vars stellen dit per diepgang af.

Annuleren is async-veilig

Een door de gebruiker gestart annuleren werpt een ResearchCancelled op moduleniveau op, die elke task-handler opnieuw doorgooit. Geen verweesde threads, geen zombie LLM-aanroepen.

Checkpoints naar GCS

Lange deep runs bewaren tussenliggende staat in Google Cloud Storage. Een gecrashte run hervat in plaats van opnieuw te beginnen.

Geheugen + knowledge graph

Eerdere onderzoeksbevindingen worden opnieuw geïnjecteerd in verwante queries. De knowledge graph houdt entiteiten over studies heen bij, zodat claims over studies heen gevalideerd kunnen worden en tegenstrijdigheden aan het licht komen.

KB-limiet per agent

Elke ElevenLabs-stemagent heeft op enig moment hoogstens MAX_AGENT_KB_DOCS onderzoeksdocumenten gekoppeld (standaard 3). De oudste wordt bij een nieuwe koppeling verwijderd, zodat de werkverzameling van de agent scherp blijft.

Podcast met twee presentatoren genereren

Elke synthese kan opnieuw worden weergegeven als een podcast met twee presentatoren (Maya + Barnaby) via ElevenLabs TTS. Dit is dezelfde afkomst waarop de podcasts van rutgertuit.nl draaien.

Wat er onder draait.

• Google ADK — het agent-framework. 24 op maat gebouwde agents (query_analyzer, study_planner, iterative_researcher, claim_validator, qa_anticipator, strategic_analyst, synthesis_evaluator, podcast_generator, watch_checker, memory_extractor, …).
• Gemini — 2.5 Flash voor analyse + bronnengebaseerd studieonderzoek, 2.5 Pro voor strategische analyse, Deep Research als autonome agent voor complexe studies.
• OpenAI o4-mini — synthese + claimvalidatie. Betere detectie van tegenstrijdigheden voor deze prijs dan de Gemini-alternatieven tijdens de evaluatie.
• Grok — optionele secundaire provider voor specifieke fasen.
• ElevenLabs Conversational + TTS — vier inkomende stemagents en de uitgaande podcastgenerator.
• Flask + Gunicorn — Python-backend. Blueprints voor health, webhook, ui_api, explore.
• Observable Framework — het /explore-dashboard. Visualiseert onderzoeksjobs, kosten, pipeline-traces, knowledge graph. Ingebouwd in de Docker-image.
• Google Cloud Run + Secret Manager + GCS — serverless runtime, secrets, persistentie van resultaten. Multi-stage Dockerfile (Node 20 bouwt het dashboard, Python 3.11 draait de app).