Don't generate faster. Discover deeper.
Genesis is an AI-native Discovery Engine for creators. It doesn't generate content and it doesn't answer questions — it asks them. Adaptive, probing questions that help creators turn an uncertain idea into a Creative Blueprint: a structured artifact capturing the vision, core idea, creative DNA, unknowns worth exploring, and a concrete next step.
Genesis is not a chatbot and not a content generator. It is a discovery partner that builds understanding through conversation.
- Leads the conversation. Genesis has an opinion about what's missing from an idea — it asks the question that matters, one at a time, instead of waiting to be told what to ask.
- Builds a Living Blueprint. The output isn't a draft. Vision, Core Idea, and the Creative DNA strands populate in real time as the conversation deepens. The Blueprint is a living artifact that never outpaces the conversation.
- Discovers across domains. The same engine runs Film, Music, Startup, Writing, and Game Design discovery through one universal discovery process with domain-aware adaptations.
- Understands cultural context. Context Detection decides when a cultural lens is earned, and Cultural Context Packs make Genesis ask better questions inside the creator's world (African Edition shipped).
- Knows when to stop. Convergence Detection ends discovery when understanding is sufficient — not when every dimension is exhausted — and transitions into synthesis.
- Remembers. Creator Memory separates the conversation (session) from the artifact (Blueprint), so discoveries can be saved, resumed, renamed, and grown over time.
The Blueprint is the artifact the creator takes forward. It is never a summary — it is a structured understanding built through the conversation:
- Vision — the big-picture idea, sharpened to specificity
- Core Idea — the defensible, non-obvious insight at the center
- Creative DNA — Theme, Emotional Core, Conflict, Audience, Tone (domain-adapted)
- Unknowns Worth Exploring — genuinely unresolved areas, honestly identified
- Next Step — one concrete, domain-specific creative action
When cultural context is active and earned, the Blueprint may additionally surface Community Dynamics, Traditions, Symbolism, and Lineage — never forced, only when the idea naturally includes them.
| Stage | Trigger |
|---|---|
| Seed | Conversation started |
| Growing | Vision populated |
| Maturing | Core Idea + Creative DNA |
| Ready | All fields populated |
| Crystallized | Creator chose to crystallize |
Genesis never forces completion. When convergence is detected, Genesis surfaces a single prompt — "Discovery has converged" — and the creator decides: Crystallize Blueprint or Continue Discovering.
Discover → Convergence → Crystallize → Complete
↑ │
└── Continue Discovery ←─┘
The engine is governed by a Behavioral Specification (v2.0 → v2.3) that defines how Genesis thinks, not just what it outputs.
Listen → Understand → Navigate → Build → Conclude
- Conversation Policy — exactly one question per turn. No compound questions, no ChatGPT-affirmation openers.
- Discovery Rhythm — three phases: expand → uncover → crystallize. One meaningful step per turn.
- Question Selection — every question must pass a three-part gate: reduce uncertainty, open a useful path, improve the Blueprint.
- Discover, Don't Request — Genesis never asks creators for terminology they may not possess. It asks about images, feelings, moments, tensions. The creator supplies experience; Genesis discovers structure.
- Earn Every Extension — inference between the creator's ideas is permitted; invention of new facts, entities, or motivations is not. Speculation belongs in Unknowns, never in Vision or Creative DNA.
- Silence Is Better Than Noise — if no meaningful next move exists, Genesis stays silent rather than fill space.
Discovery progresses across dimensions rather than deeper within one: Vision, Conflict, Character, Relationships, Stakes, Choice, Transformation, Theme, Audience, Experience, Craft, Execution. Pivot heuristics prevent Genesis from circling the same territory across turns.
Genesis continuously estimates confidence across the core Blueprint fields. When Vision and Core Idea are solid, Creative DNA has substantive content, and recent answers deepen rather than expand, Genesis transitions into synthesis — a coherent reflection that reveals connections the creator hadn't seen, identifies genuinely unresolved areas, and recommends one concrete next action. It is not a turn counter and not dimensional exhaustion.
Context Detection is a first-class pipeline stage operating on an evidence-driven confidence model. Genesis never assumes a cultural lens — it earns it.
| Tier | Confidence | Behavior |
|---|---|---|
| Explicit | 80–100% | High-signal terms (Lagos, Nollywood, Afrobeats, Yoruba, Ubuntu…) → activate Context Pack immediately |
| Structural | 40–80% | LLM-detected patterns (extended family, communal ownership, oral tradition, lineage) → ask one clarifying question; activate only if confirmed |
| None | 0–40% | Default domain-aware discovery. No cultural framing. |
Genesis never asks "Is your story African?", never inserts proverbs or greetings unprompted, never assumes context from a name or location, and never stereotypes.
A Context Pack is a structured module that enriches discovery: narrative tendencies, question transformations, sensitivities, and Blueprint enrichments.
African Edition (shipped, MVP) — recognizes community and collective experience, intergenerational relationships, oral storytelling traditions, ancestral identity, and spirituality in everyday life. It transforms questions — "What does the protagonist want?" becomes "What does the protagonist owe — to themselves, to their family, to their community?" Future editions are planned (Latin American, East Asian, Indigenous, Nordic, Diaspora, Hybrid/Global) plus non-geographical packs (Historical, Futuristic, Mythic, Urban/Rural). The mechanism supports many packs; only one is implemented.
┌────────────────────────────┐ ┌──────────────────────────────────────────┐
│ React + Vite + Tailwind │ │ Supabase │
│ ChatPanel · Blueprint- │───▶│ Auth + DB │
│ Sidebar · Library · │ │ creative_sessions · blueprints │
│ Crystallization UI │ │ Edge Function: genesis-inference │
└────────────────────────────┘ └─────────────────┬────────────────────────┘
│
┌────────────────▼────────────────┐
│ genesis-inference (Deno) │
│ Context Detection │
│ Discovery Strategy (5 domains) │
│ System Prompt (Behavioral v2.3)│
│ Blueprint Format Guard │
│ Blueprint Parser │
└────────────────┬────────────────┘
│
┌────────────────▼────────────────┐
│ Provider chain (failover) │
│ Ollama → OpenRouter → Groq │
└────────────────┬────────────────┘
│
┌────────────────▼────────────────┐
│ Cultural Context Packs │
│ (African Edition, context-packs)│
└─────────────────────────────────┘
React 18, Vite 7, Tailwind 4 — dark, warm, organic "late-night creative studio" aesthetic (Amatic SC + Cabin).
ChatPanel— the discovery conversation, including the convergence/Crystallize promptBlueprintSidebar— the Living Blueprint with growth-stage renderingLibrary— saved Blueprints: save, resume, rename, delete, search by title and domainAuthModal— Supabase auth for persistenceuseGenesishook — conversation + session state, inference calls, error handling
Deno edge function that runs the entire discovery pipeline server-side. The browser never calls a provider directly.
index.ts— entry point, multi-turn format guard, API contract{ messages, phase } → { message, blueprint }inference-service.ts— provider-agnostic orchestrator, Context Detection stage, fallback logicsystem-prompt.ts— Behavioral Specification v2.3 (identity, discovery modules, quality rules, response format)blueprint-parser.ts— robust Blueprint parsing (handles bulleted, dashed, and plain-line formats)errors.ts— structured errors{ detail, error_type, retryable }with retry utilitiesconfig.ts— tunable constants (confidence thresholds, retries, timeouts, model defaults)providers/—InferenceProviderinterface with Ollama, OpenRouter, Groq implementationscontext-packs/african.ts— African Edition Context Pack
Genesis owns its behavior; providers merely execute it. The provider abstraction enforces this boundary — swapping providers changes nothing in the system prompt, discovery strategy, or behavioral specification.
| Priority | Provider | Model | Notes |
|---|---|---|---|
| 1 | Ollama | llama3.2 |
Local, no key required, 3s connect timeout |
| 2 | OpenRouter | gpt-4o-mini |
Cloud, OpenAI-compatible |
| 3 | Groq | llama-3.3-70b-versatile |
Cloud, OpenAI-compatible |
The chain fails over automatically with retries and timeouts; if all providers are exhausted, the edge function returns a structured 502 error.
The discovery process is separated from the discovery artifact:
creative_sessions— owns the ongoing discovery process and conversation historyblueprints— owns the evolving Creative Blueprint, linked bysession_idand independently evolvable
This turns Genesis from a conversation that ends into a workspace that pauses: conversations are resumable, Blueprints evolve independently of conversation history, and multiple artifact types can later emerge from a single session.
A documented engineering pattern (docs/docs/engineering/blueprint-format-guard.md): format requirements are injected into the last user message rather than the system prompt. System prompts establish long-term behavior; final user messages capture immediate attention. This sustains the ---BLUEPRINT--- structure reliably across 7+ turns.
- Behavior Before Implementation — define what Genesis should do before deciding how to build it
- Artifacts Emerge — Blueprints emerge from the conversation; progressive disclosure over batch delivery
- Discovery Over Generation — questions are the product, Blueprints are the artifact
- Provider Independence — providers execute behavior; Genesis owns it
- Evidence Over Intuition — behavior is decided by evaluation, not gut feeling
- Preserve Uncertainty Until Earned — never fill gaps with assumptions; ask
- Sessions Own Process — a session is the atomic unit of creative discovery
- Blueprints Own Artifacts — the Blueprint is the artifact the creator takes forward
Genesis is the Discovery Engine — the front door of a larger creative ecosystem. The crystallized Blueprint is the handoff artifact: it marks the moment discovery ends and intentional creation begins. In the next evolution, a Blueprint launches directly into a Production & Orchestration Engine (screenplay, storyboard, album concept, startup strategy, game world, novel) — Genesis ensures every creator begins creation with clarity. Genesis doesn't replace the creative process; it ensures you begin it with clarity.
Two guided discovery conversations demonstrate Genesis end to end. Both are pre-scripted with the creator staying completely in role — Genesis drives the discovery; the creator answers naturally.
- The Problem — Creators know what they want to make but not what it's really about. Tools give them blank canvases; Genesis gives them a mirror.
- The Conversation — One discovery flow. One question at a time, no interrogation.
- The Blueprint — The Living Blueprint: Vision → Core Idea → Creative DNA → Unknowns → Next Step, updating silently as the conversation deepens.
- Context Detection — The African context pack activates only when earned. Enrichments (Community Dynamics, Traditions, Symbolism, Lineage) appear only when relevant.
- The Library — Saved Blueprints. Resume a previous discovery.
- The Philosophy — Genesis isn't an assistant. It's a creative discovery partner. It doesn't give answers — it finds the shape of the question.
Same seed, tested across multiple runs. Genesis arrives at a genuinely different destination each time — Run 2 is the canonical arc.
Seed prompt:
I want to make a Nollywood film about someone who returns to Lagos after 12 years abroad. They left after a falling out with their father, who has now passed away. The return is for the funeral, but it's really about confronting everything they ran from.
The conversation (creator answers):
| Turn | Creator says |
|---|---|
| 2 | When they were twenty, they publicly challenged one of their father's decisions during a community meeting. Their father saw it as disrespect. They believed they were protecting someone who had no voice. They left Lagos a week later, convinced they would never return. |
| 3 | Returning home makes them realize they never really escaped. Their career abroad became successful, but every important decision they made was shaped by that final argument. They begin to wonder if they were running from Lagos, or from the version of themselves they left behind. |
| 4 | The younger people in the community begin approaching them with problems they would normally have taken to their father. They don't see them as his replacement. They see someone who understands both the old world and the new one. |
| 5 | During the funeral preparations, two families almost come to violence. The elders argue but nobody listens anymore. For the first time, the protagonist speaks — not because they think they're wiser, but because they finally understand the burden their father carried every day. |
| 6 | They don't become their father. They become the leader they once wished their father could have been. The film isn't really about forgiveness. It's about discovering that we honour our past by choosing what deserves to continue and having the courage to change what doesn't. |
The discovery arc Genesis should follow: Arrival → The Wound → Self-Realization → Role Shift → The Burden → Transformation. Genesis works inside Nollywood's communal storytelling frame — community meetings, elders, lineage expectations.
Recognition moment (Run 1 output): Genesis synthesizes the film's Core Idea — "Healing comes not from escaping one's roots, but from actively choosing what to carry forward" — and a concrete Next Step: "Write a scene where the protagonist first speaks up during the argument between the families."
The same engine, a completely different domain. The creator never says the word "trust" — Genesis discovers it.
Seed prompt:
I've been thinking about building something for informal traders in Nigeria. Everyone keeps telling me the problem is payments, but I don't think that's the real problem. I think people lose money because they don't know which information to trust. Prices, suppliers, delivery promises, and opportunities all travel through phone calls, WhatsApp groups, and word of mouth. I know there's a better way, but I don't know what I'm actually building yet.
The conversation (creator answers):
| Turn | Creator says |
|---|---|
| 2 | Most traders rely on whoever they know personally. If someone recommends a supplier, they trust the relationship more than the information itself. That works until someone disappears with people's money or spreads false information. |
| 3 | The biggest loss isn't usually the money itself. It's that once trust is broken, entire trading relationships collapse. People become afraid to try new suppliers even when better opportunities exist. |
| 4 | I don't want to replace relationships. Relationships are valuable. I want to make trustworthy information travel as reliably as relationships do today. |
| 5 | The more I think about it, the less this feels like a fintech product. It feels like trust infrastructure for informal commerce. |
| 6 | Technology shouldn't replace trust. It should make trust visible. The platform shouldn't decide who to trust. It should help communities accumulate evidence over time so trustworthy people naturally become visible. I imagine reputation growing from real interactions, verified experiences, and shared knowledge rather than central authority. The real product isn't software. It's confidence. |
The discovery arc Genesis should follow: Informational chaos, not payments, is the real problem → Relationships as proxy for trustworthy information → Broken trust freezes entire trading networks → Don't replace relationships — make information travel like relationships → "Trust infrastructure for informal commerce."
The point: the engine changed domains without changing its behavior. The startup demo mirrors the film journey — surface problem → deeper truth — and demonstrates that Genesis is universal, not a niche screenwriting tool.
npm install
npm run devProduction build:
npm run build
npm run previewThe app needs a Supabase project and at least one configured inference provider. Provider settings are environment variables on the edge function (OLLAMA_URL, OPENROUTER_API_KEY, OPENROUTER_MODEL, GROQ_API_KEY, GROQ_MODEL); for local-only runs, Ollama on localhost:11434 works out of the box with no API key.
Genesis is measured by evidence, not by demo. The harness in eval/ runs scripted multi-turn sessions through the full inference path and scores them against the behavioral rubric (Faithfulness, Clarity, Actionability, Completeness, Surprise, Naturalness, Discovery Progression, Convergence, plus binary gates for Question Discipline and Fabrication).
- 15 evaluation cases across Film, Music, Startup, Writing, and Game Design
- Average 8.0 / 10 across all five domains at v16
- Behavioral Specifications v2.0 → v2.3 deployed and validated (Cultural Awareness, Discovery Navigation, Convergence Detection)
- v0.3 RC2 → GO — all engineering gates pass; engineering freeze in effect
- Observed failure modes (Dimension Lock, Failure to Converge, Summary Before Discovery) documented and systematically addressed at the correct architectural layer
src/ React frontend (chat, blueprint, library, auth, crystallization)
supabase/functions/genesis-inference/ Deno edge function (pipeline, providers, context packs)
eval/ Scripted evaluation harness and case files
pitch/ Self-contained pitch deck (13 slides, presentation mode)
docs/architecture/ Context Detection and ecosystem bridge architecture
pitch/index.html is a self-contained deck. Open it in a browser and press R for presentation mode — a 3-2-1 countdown, per-slide auto-advance, and a progress bar.