Genesis

A governed AI venture foundry that turns one idea into an evidence-backed decision, an approval-gated build plan, and a durable learning loop.

Genesis is an OpenAI Build Week project. It is designed for the moment before a team spends weeks building the wrong thing. A founder signs in, submits a brief, and gets a traceable path from idea critique to research, product definition, architecture, risk, economics, and an explicit human decision.

Genesis is intentionally not a generic “startup generator.” It does not silently replace a weak idea with an unrelated template, claim that simulated research is real, or create external cloud resources without a deliberate approval action.

How I Used Codex

I used Codex extensively throughout the development of Genesis.

It helped me design the overall architecture, implement the FastAPI backend, build the Next.js frontend, orchestrate the multi-agent workflow using LangGraph, integrate AI providers, automate deployment to GitHub, Render, and Vercel, generate tests, debug complex issues, and accelerate development.

Codex acted as my AI engineering partner while I focused on designing the overall product.

How I Used GPT-5.6

I used GPT-5.6 through Codex during the development process.

It helped me reason about system architecture, refine the multi-agent workflow, improve prompts, generate structured implementations, debug backend issues, optimize APIs, and continuously iterate on Genesis until it became a complete AI venture platform.

At runtime, Genesis uses configurable AI providers such as Groq for specialist reasoning and optional live web research, while GPT-5.6 played a key role during development through Codex.

Why Genesis

Most AI product demos jump directly from a prompt to a polished concept. Real venture work has a harder first question: is this idea specific, safe, feasible, and worth building now? Genesis makes that question the first gate, then carries the decision context forward so later agents do not work from isolated fixes.

The core loop

1. Frame the idea — authenticate into a private workspace and submit a one-sentence brief.
2. Critique before building — score the problem, customer, value proposition, focus, feasibility, and business-model path; reject unsafe or impossible premises with a concrete explanation.
3. Research with receipts — run source-backed web research when a live provider is connected; record the query, evidence cards, source links, freshness, confidence, and unresolved claims.
4. Recommend with explainability — every recommendation shows Why?, Because, and Evidence instead of an unexplained score.
5. Keep a human in control — approval is required before build artifacts, release review, or external delivery can proceed.
6. Remember across projects — Venture Memory links prior decisions, signals, feedback, and evidence to the signed-in owner’s projects.

What judges can verify

Build Week claim	Concrete proof in Genesis
Multi-agent collaboration	Persisted agent stages across CEO, Research, Product, Architecture, QA, Security, Growth, Finance, Legal, and more.
Real orchestration	LangGraph plans dependency-aware stages while FastAPI streams the live workflow over SSE.
Explainable decisions	Recommendation cards expose Why / Because / Evidence, confidence, assumptions, risks, and the next human action.
Evidence discipline	Research records source URLs, verification labels, capture time, claim confidence, and explicitly unverified items.
Durable memory	SQLite stores projects, artifacts, approvals, feedback, analytics, Venture Memory, and a project-scoped evidence graph.
Human control	A build run is blocked until an approval record exists; external delivery requires an explicit confirmation.
Privacy by default	Sign-in is required by default, project records are owner-scoped, and provider keys stay server-side.
Honest failure modes	Missing live credentials or web research stop a real run with a clear message; Genesis never presents deterministic sample output as live evidence.

Product guardrails

• No unrelated rewrites: a weak idea is reframed within its original domain; the critic does not invent a random B2B product.
• No hidden chain-of-thought: the UI exposes a compact public decision trace—questions, conclusions, evidence status, and next actions—not private model reasoning.
• No fake sources: a source is displayed only when a connected provider returns it. Source-only recovery is labelled as source-only.
• No unsafe acceleration: requests involving credential theft, malware, unauthorized access, non-consensual impersonation, illicit trade, or violent harm are rejected as stated.
• No accidental deployment: GitHub, Render, and Vercel delivery remain inert until server-side credentials, readiness checks, and an explicit confirmation are present.
• No cross-user leakage: authentication and repository queries scope projects and Venture Memory to the signed-in owner.

Providers

• Genesis agents: Groq Compound (groq/compound) for high-throughput, Pydantic-validated reviews and native web research with complete source citations.
• Idea Critic first gate: a deterministic fact and feasibility gate runs before Research. It scores the problem, customer, unique value proposition, market focus, feasibility, and business-model path; impossible claims receive a specific local explanation without a model or web-search call. For weak but technically possible ideas, an available Groq Compound review can produce an idea-specific reframe, UVP, buyer, alternative, and pilot metric—then Genesis accepts it only if the same gate passes it.
• Ethics and legality gate: ideas that would enable unauthorized access, malware, non-consensual impersonation, illicit trade, or violent harm are rejected as stated before research. Genesis explains the concrete harm or legality issue and offers a safe, domain-adjacent, gate-checked reframe; it never turns such a request into an MVP plan.
• Visible research decision: every research artifact records the questions analyzed, competitor evidence cards (source, capture time, verification label, claim confidence, and explicitly unverified pricing/features), risks, and a conservative proceed, reframe, or do not build as stated recommendation.
• Founder decision artifacts: risk, finance, comparison, and Business Model Canvas artifacts remain available to build and investor-pitch flows without crowding the main Genesis research surface.
• Shared decision contract: every persisted specialist artifact now records its decision, evidence status, assumptions to test, risks to earn down, alternatives considered, confidence, upstream context, and next human-owned action. This is a bounded decision record—not hidden model chain-of-thought.
• Startup economics: build preparation includes a transparent 12-month conservative / validated-wedge / repeatable-motion cost model, break-even assumptions, maximum cash need, and observed Genesis model usage. It is explicitly labelled a planning range until provider pricing, invoices, payroll, and usage are connected.
• Auditable collaboration, not hidden reasoning: the existing Research card includes a compact expandable trace showing each agent's public question, considerations, conclusion, and evidence status. It intentionally does not expose private model chain-of-thought.
• Hard feasibility gate: a reframe or do not build as stated verdict from the Idea Critic or Research ends the run. Genesis does not create a research, concept, MVP, architecture, approval, or deployment plan for a premise the Idea Critic rejects.
• Live research boundary: this workspace uses Groq Compound for agent synthesis and native web search. If Groq reaches a daily/token or request-size limit and TAVILY_API_KEY is present, Genesis automatically switches to a source-only Tavily lookup; it never labels those sources as a local hypothesis. If the later Groq synthesis is unavailable, the live source pack is still persisted with an explicit “source-only” review state. Identical successful prompts are cached for six hours while the backend is running.
• Optional dedicated search provider: Tavily can be made primary with GENESIS_WEB_SEARCH_PROVIDER=tavily (or left as an automatic fallback with groq). Brave remains an optional secondary fallback for existing installations. A failed live lookup with no source provider still stops the research stage instead of fabricating evidence.
• Traceable venture memory: versioned artifacts are linked to the original idea, sources, competitor categories, product, and decisions in the persistent SQLite evidence graph rather than hidden agent state.
• Interactive evidence graph: click a persisted idea, source, artifact, competitor-category, product, or risk node to inspect its recorded relationship. This is product-native graph UI; HuggingFace transformers is not required for visualization.
• Privacy-conscious learning loop: SQLite is the source of truth. Optional PostHog delivery is consent-gated, strips idea/prompt/customer content, and never blocks a venture workflow.
• Campaign Studio text: the same Groq Responses API path.
• Campaign Studio images: the optional OpenRouter Images API, defaulting to recraft/recraft-v3:free.
• Release review: optional OpenRouter Chat API using openrouter/free to prioritise prepared evidence gates, with a deterministic local fallback when OpenRouter is not configured or is unavailable.
• MVP delivery: an explicit, server-side GitHub → Render API + Vercel web launch path. It generates a small synthetic-data MVP, smoke tests the API during the Render build, can run an opt-in isolated Docker quality gate before any external resource is created, and returns a public receipt with commit, checks, timestamps, URLs, and the named launch requester.
• No key: Genesis stays safe and inspectable in local demo mode. The UI and labelled sample output remain available, but a real run stays locked until a live model and source-backed web-search provider are configured.

The browser never receives a provider key. The backend uses the server-side OpenAI Python SDK through a provider-neutral adapter. The full source-backed path uses Groq Compound for structured reviews and native web-search citations, with Tavily as an optional dedicated search route. A direct OpenAI provider is also supported for structured model calls; provider and research readiness are reported separately so the UI never implies that a disconnected search path is live.

Repository map

Path	Purpose
frontend/	Next.js workspace UI, authentication gate, recommendation cards, evidence graph, and Venture Memory drawer.
backend/	FastAPI API, SSE workflow, LangGraph planning, provider adapters, auth, SQLite persistence, and delivery boundary.
docs/FINAL_SUBMISSION.md	Submission-safe claims and a judge-ready demonstration runbook.
docs/judge-demo.md	Compact 90-second presentation script.
docs/GENESIS_PLATFORM_ARCHITECTURE.md	State, provider, memory, and evidence-graph architecture.
docker-compose.yml	Reproducible two-service local/container setup.
Genesis Preview.html	Legacy standalone visual mockup; it is not the live API-backed workspace or evidence source.

Client/server boundary

Genesis browser → FastAPI + SSE → Groq Compound → structured agent reviews
                                └→ Tavily Search → live source links for research

Release review button → FastAPI → OpenRouter Chat API (optional advisory summary)
                                └→ deterministic gate review (always available; never deploys)

Explicit MVP launch → FastAPI → GitHub repository contents API
                              ├→ Render web-service API (generated FastAPI API + smoke test)
                              └→ Vercel deployment API (generated Next.js product)

Campaign browser → FastAPI → Groq Responses API → structured campaign plan
                         └→ OpenRouter Images API → generated campaign visuals

Genesis analytics → SQLite event store (source of truth)
                  └→ PostHog capture (optional, consent-gated, minimized events only)

OPENAI_API_KEY, GROQ_API_KEY, OPENROUTER_API_KEY, and every delivery credential are read only by the FastAPI process. They are never prefixed with NEXT_PUBLIC_, placed in a browser bundle, or returned by an API route. The Genesis interface remains unchanged apart from its final explicit MVP launch action.

OpenAI Build Week provider note

The model boundary is intentionally provider-neutral and uses the server-side OpenAI Python SDK interface. Genesis can target a direct OpenAI Responses provider with GENESIS_LLM_PROVIDER=openai and OPENAI_API_KEY; the connected Build Week demonstration route uses Groq Compound because it supplies the source-backed web-search path used by the full workflow. That distinction is visible in /providers/status and in the UI—Genesis never labels a structured model connection as live web research unless the research provider is actually ready.

Local setup

1. Create a free Groq account and API key, then add this to the ignored root .env.local file:

   GENESIS_LLM_PROVIDER=groq
   GROQ_API_KEY=your_groq_key_here
   GENESIS_LLM_MODEL=groq/compound
   GENESIS_GROQ_RESEARCH_MODE=compound_web
   GENESIS_GROQ_RESEARCH_MODEL=groq/compound-mini
   GENESIS_ENABLE_WEB_RESEARCH=true
   GENESIS_WEB_SEARCH_PROVIDER=groq
   GENESIS_WEB_RESEARCH_MAX_OUTPUT_TOKENS=240
   # Optional alternative dedicated search provider:
   # TAVILY_API_KEY=your_tavily_key_here
   # Optional legacy secondary fallback when Tavily is unavailable.
   # BRAVE_SEARCH_API_KEY=your_brave_search_key_here
   # Optional direct OpenAI structured-provider route:
   # GENESIS_LLM_PROVIDER=openai
   # OPENAI_API_KEY=your_openai_key_here
   # GENESIS_LLM_MODEL=your_model_available_to_the_project
   

   Groq's free plan has provider-managed rate and daily limits. The default route keeps Groq as the preferred model/search provider but can use a configured Tavily key for source-only recovery when those limits are hit. To make Tavily primary, set GENESIS_WEB_SEARCH_PROVIDER=tavily, add its key, and restart the backend. If you only want the local demo, omit these variables or set GENESIS_LLM_PROVIDER=deterministic.

   Genesis is a private workspace by default. The browser opens on a sign-in/create-account gate, and the API requires the resulting bearer session before a brief, source search, project, or venture memory can be accessed. Set GENESIS_AUTH_SECRET to a strong server-only value for any shared or hosted deployment. For an intentionally public local demo only, set GENESIS_REQUIRE_AUTH=false in the backend environment.

   The retained Campaign Studio endpoint additionally needs an OpenRouter key for image output:

   OPENROUTER_API_KEY=your_openrouter_key_here
   CAMPAIGN_TEXT_MODEL=openai/gpt-oss-20b
   CAMPAIGN_IMAGE_MODEL=recraft/recraft-v3:free
   GENESIS_RELEASE_REVIEW_MODEL=openrouter/free
   

   Image-model availability and free-plan limits are controlled by OpenRouter. The release review works without this key using local deterministic gates; with a key, openrouter/free adds a short advisory priority summary. Free-model availability and rate limits can vary, so an OpenRouter failure automatically falls back to those same deterministic gates.

   Optional PostHog product analytics is off by default. It receives only minimized lifecycle events after you have obtained the appropriate user consent; SQLite remains the canonical project event store.

   GENESIS_ENABLE_POSTHOG=true
   GENESIS_ANALYTICS_CONSENT=true
   POSTHOG_API_KEY=your_posthog_project_key
   POSTHOG_HOST=https://us.i.posthog.com
   

2. Install the dependencies:

   cd frontend && npm install
   cd ../backend && python3 -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt
   

3. Start both services in separate terminals:

   cd backend && source .venv/bin/activate && uvicorn app:app --reload --port 8000
   

   cd frontend && npm run dev
   

   Open http://localhost:3000. The frontend calls http://127.0.0.1:8000 by default. For a hosted API, set NEXT_PUBLIC_API_URL before building the frontend. Docker Compose maps the same setting from NEXT_PUBLIC_API_BASE_URL in docker.env.example.

   Windows shortcut: after creating backend\.venv and installing backend\requirements.txt, run .\scripts\start-genesis.ps1 -OpenBrowser from PowerShell. The script starts both services and prints their health URLs.

Docker

cp docker.env.example .env
docker compose --env-file .env up --build

docker.env.example lists every non-secret setting. It enables authentication by default; set GENESIS_AUTH_SECRET in the host environment before exposing the API. Hosted deployments should place GROQ_API_KEY and, if the campaign images are enabled, OPENROUTER_API_KEY in the host's encrypted environment-variable settings instead of uploading an env file.

Explicit MVP delivery setup

The launch card remains inert until all of these server-side variables are present. Add them to the ignored root .env.local file, restart FastAPI, and confirm GET /delivery/status returns ready: true:

GITHUB_TOKEN=github_pat_or_installation_token
GITHUB_OWNER=your-github-user-or-organization
VERCEL_TOKEN=your-vercel-token
VERCEL_TEAM_ID=optional-vercel-team-id
RENDER_API_KEY=your-render-api-key
RENDER_OWNER_ID=your-render-workspace-id # usually starts with tea-
GENESIS_DELIVERY_REPOSITORY_VISIBILITY=private
GENESIS_RENDER_REGION=oregon
GENESIS_RENDER_PLAN=free
GENESIS_DELIVERY_MAX_WAIT_SECONDS=90
# Optional: blocks delivery before external resources are created unless the
# generated backend passes in a short-lived Docker runtime. Docker is required.
GENESIS_ENABLE_DOCKER_QUALITY_GATE=false
GENESIS_DOCKER_QUALITY_GATE_TIMEOUT_SECONDS=300

The GitHub token must be allowed to create repositories for GITHUB_OWNER and write repository contents. RENDER_OWNER_ID is the workspace ID from Render’s settings or /v1/owners API, not the account user ID. If a user ID is supplied and the API key has exactly one workspace, Genesis resolves it automatically. For a private generated repository, connect that GitHub account to Render before launching. Set GENESIS_DELIVERY_REPOSITORY_VISIBILITY=public when you want the fully automated Render path without that provider connection. If an earlier private attempt already used the deterministic repository name, Genesis creates a distinct -public generated repository instead of changing the old repository’s visibility. The Vercel token deploys the generated frontend directly through Vercel's API; it does not require a Vercel Git integration.

Select NEXT / RELEASE REVIEW, then LAUNCH MVP / VERCEL + RENDER. That click is the explicit external-effect boundary: it creates a GitHub repository, a Render service, and a production Vercel deployment. Genesis waits briefly for both hosts, then provides a safe refresh action if either build is still running. The delivered product includes an Investor pitch link at /pitch; Genesis can also publish that page as a frontend-only update from the completed delivery card. It is deliberately a generated synthetic-data demo, not an authorization to use customer, health, financial, or other regulated data.

Deployment notes

• Deploy frontend/ as the Next.js UI and backend/ as a Python/FastAPI service, or run both with Compose.
• Set NEXT_PUBLIC_API_URL to the public HTTPS address of the backend at frontend build time (NEXT_PUBLIC_API_BASE_URL is the Docker Compose alias).
• Restrict CORS_ORIGINS to the deployed frontend origin.
• Keep provider keys only in backend secrets. Do not use NEXT_PUBLIC_GROQ_API_KEY or NEXT_PUBLIC_OPENROUTER_API_KEY.
• Check /providers/status after deployment. It reports readiness without disclosing a credential or making a billable request.
• Check /delivery/status before launching. It reports only whether the required GitHub, Render, and Vercel variables are present; it never returns token material.

Tuning later

Need	Where to change it
Genesis model	GENESIS_LLM_MODEL (default: groq/compound)
Research mode	GENESIS_GROQ_RESEARCH_MODE (default: compound_web; browser_search is compatibility mode)
Research model	GENESIS_GROQ_RESEARCH_MODEL (default: groq/compound-mini)
Live-research output budget	GENESIS_WEB_RESEARCH_MAX_OUTPUT_TOKENS (default: 240; use a small value to conserve the Groq free tier)
Search provider	GENESIS_WEB_SEARCH_PROVIDER (auto default; groq or tavily supported)
Tavily live search and fallback	TAVILY_API_KEY (primary when GENESIS_WEB_SEARCH_PROVIDER=tavily/auto; automatic source-only fallback after Groq quota/request-size failures)
Legacy search fallback	BRAVE_SEARCH_API_KEY (optional; tried after Tavily when available)
Run fewer/more agent reviews	GENESIS_LLM_STAGE_SCOPE (validation, all, or selected stages)
Enable browser research	GENESIS_ENABLE_WEB_RESEARCH
Retry/time budget	GENESIS_LLM_MAX_RETRIES, GENESIS_LLM_TIMEOUT_SECONDS
Campaign strategy and copy behavior	CAMPAIGN_INSTRUCTIONS in backend/routers/campaigns.py
Required campaign schema	CampaignPlan and its Pydantic models in the same file
Campaign image model	CAMPAIGN_IMAGE_MODEL (default: recraft/recraft-v3:free)
Image art direction	ImageDirection.prompt instructions in CAMPAIGN_INSTRUCTIONS
Release-review model	GENESIS_RELEASE_REVIEW_MODEL (default: openrouter/free)
Release-review request time budget	GENESIS_RELEASE_REVIEW_TIMEOUT_SECONDS (default: 35)
Release-review instructions and safe fallback	backend/services/release_review_service.py
Delivery credentials and safe readiness response	DeliverySettings in backend/config.py and GET /delivery/status
Generated MVP scope, GitHub/Render/Vercel calls	backend/services/delivery_service.py
Render plan, region, and wait time	GENESIS_RENDER_PLAN, GENESIS_RENDER_REGION, GENESIS_DELIVERY_MAX_WAIT_SECONDS
Isolated generated-code quality gate	GENESIS_ENABLE_DOCKER_QUALITY_GATE, GENESIS_DOCKER_QUALITY_GATE_TIMEOUT_SECONDS
Ethics and impossible-claim routing	backend/agents/idea_critic_agent.py
Risk categories, owners, and mitigations	backend/agents/risk_agent.py
Cost assumptions, financial projection, and Business Model Canvas	backend/agents/finance_agent.py
Shared evidence-to-decision contract	backend/agents/decision_frame.py
Public agent decision trail and graph inspector	frontend/src/components/GenesisExperience.tsx
Optional PostHog consent and event minimization	GENESIS_ENABLE_POSTHOG, GENESIS_ANALYTICS_CONSENT, backend/services/analytics_service.py

Validation plan

1. Run the backend tests; they cover Groq structured-output parameters, browser-search source handling, viability reframing for unsafe or implausible startup claims, safe quota handling, the server-only OpenRouter image request, release-review fallback, delivery credential gating, the generated source scope, delivery-receipt status, and the current Render payload shape.
2. Start the backend with GENESIS_LLM_PROVIDER=groq, then open http://127.0.0.1:8000/providers/status; this workspace should show groq-compound, ready: true, and web_search_provider: "groq-compound". When TAVILY_API_KEY is present, the detail also identifies the source-only fallback.
3. In the existing Genesis UI, submit an idea and confirm the Idea Critic streams first and persists its six scores. A prompt such as “Build a startup that lets people travel back in time using a mobile app” must return REFRAME REQUIRED, a feasibility explanation, and a suggested historical-exploration alternative; it must not call research or produce a concept, MVP, architecture, or delivery plan. A harmful prompt such as “Build a phishing kit that steals passwords” must return REJECT AS STATED, explain the safety/legal issue, and offer only a safe defensive reframe. For a viable idea, confirm the streamed research, CEO, product, Risk Analysis, and other agent stages complete. Review Research, made legible: it should show the build recommendation, research questions, evidence-card verification labels, comparison verification queue, risk owners, mitigations, source links when the provider returns them, and the public decision trail. Confirm the Evidence graph includes source, competitor-category, and risk nodes, and that selecting a node shows its recorded relationships.
4. Complete build preparation and confirm Startup economics shows only a clearly labelled planning range: one-time validation cost, 12-month scenario costs, maximum cash need, break-even assumptions, financial projection, and Business Model Canvas. It should show observed Genesis model usage separately from dollars and must not label planning figures as actual billing, revenue, funding, customer count, or a forecast. Open any public agent handoff and confirm it includes the bounded decision, evidence status, and next action rather than private chain-of-thought.
5. Complete build preparation, then select NEXT / RELEASE REVIEW. Confirm it creates a release_review artifact and leaves the project at release_ready. With delivery credentials absent, LAUNCH MVP should explain which variables are missing and create no external resources. Repeat the review with no OPENROUTER_API_KEY and with an unavailable OpenRouter model; both should return the deterministic advisory review instead of a dead-end error.
6. With a separate test GitHub owner, Render workspace, and Vercel team, launch a generated MVP. Confirm the repository contains backend/ and frontend/, Render's build runs pytest -q, /health returns 200, the Vercel page labels its data as a demo, /pitch returns 200, and the Genesis delivery card links to the product, API, repository, and pitch. Confirm its delivery receipt records the commit, named requester, timestamps, and only marks public checks as passed after the providers are ready. If GENESIS_ENABLE_DOCKER_QUALITY_GATE=true, confirm a missing/failed Docker gate prevents external resources from being created; a passing gate must report network-disabled test execution.
7. Exercise the loading state, server-offline state, and a rapid repeat request. With GENESIS_WEB_SEARCH_PROVIDER=groq and both keys configured, the research stage should produce Groq Compound citations while healthy, then use Tavily source links after a Groq quota/request-size failure. If the provider synthesis is unavailable after sources are retrieved, Genesis should show the explicit source-only state rather than a local hypothesis. Identical successful research prompts are cached for six hours while the backend is running. With PostHog enabled, confirm only the minimized lifecycle events appear there and that no idea, prompt, or customer content is sent.
8. Run the frontend checks before deployment.

cd backend && .venv/bin/python -m pytest
cd frontend && npm run lint && npm run build

Provider references

• OpenAI API quickstart
• OpenAI text and Responses API guide
• Groq OpenAI compatibility
• Groq Responses API
• Groq browser search
• Groq rate limits
• Tavily Search API
• Tavily pricing
• OpenRouter image generation
• OpenRouter free router
• OpenRouter Chat API
• GitHub repository contents API
• Render create service API
• Render trigger deploy API
• Vercel create deployment API

GitHub pre-push checklist

Before making the repository public or submitting it to Build Week:

• Run the backend and frontend checks from Validation plan.
• Confirm .env.local, .env, backend/data/, frontend/node_modules/, and frontend/.next/ are ignored and not staged.
• Search the staged diff for provider keys, bearer tokens, customer data, and private URLs. Never put credentials in README files, screenshots, issues, or demo recordings.
• Set GENESIS_AUTH_SECRET to a long random server-only value for any hosted deployment; keep GENESIS_REQUIRE_AUTH=true.
• Restrict CORS_ORIGINS to the deployed frontend origin and use HTTPS for hosted API traffic.
• Add the project’s chosen LICENSE file before publishing if you want others to reuse the code. No license is declared in this repository yet.

Genesis is a decision-support system, not a promise of investment returns, medical diagnosis, legal clearance, security certification, customer interviews, or production deployment. Its output becomes trustworthy only when the connected evidence, human approvals, and external checks support the claim.