Create the agent
that remembers,
governs, and acts.
Launch ODEI through Codex, Claude Code, or Gemini in the terminal. Your setup AI installs the runtime on your machine; your model lane can still be Claude, ChatGPT, Gemini, your own API key, or ODEI credits. ODEI adds a persistent World Model, constitutional governance, receipts, and a real decision loop so your agent can operate across sessions instead of starting from zero.
You already pay for intelligence. ODEI lets your setup AI install a governed local runtime while your model lane stays replaceable and your data stays with you.
Choose your setup AI
Use Codex, Claude Code, or Gemini as the installation operator. ODEI does not replace that AI; it gives it a local runtime with memory, governance, and receipts.
Choose model lane
Keep Claude, ChatGPT, Gemini, your own API key, or ODEI credits as the model lane. The intelligence layer stays replaceable while ODEI owns memory, governance, and execution continuity.
Create your World Map locally
Email, calendar, docs, tasks, CRM, and files stay with you on your own machine. Your agent builds a private World Model locally instead of handing your raw operating data to another hosted AI layer.
Set governance + launch first mission
Define approvals, allowed actions, budget limits, quiet hours, and sensitive operations, then launch inbox triage, investor follow-ups, weekly operating briefs, or pipeline monitoring with receipts attached.
You do not leave with a vague waitlist promise. You leave with the first governed runtime boundary: Digital World Model, decision loop, governance boundary, and launch artifacts.
Canonical launch contracts
Assistant lane, model, governance, world sources, execution surfaces, and the first mission resolve into one launch bootstrap, one compact launch index, and the underlying launch model, launch plan, launch session, and launch resume before activation opens.
Exact intake contract
The app exposes the same structured onboarding payload that the intake API will receive: Digital World Model boundary, decision loop posture, governance boundary, and first mission. Nothing meaningful is hidden behind the form.
Digital World Model + decision loop
The launch control plane already resolves one bounded Digital World Model, one Observe -> Decide -> Act -> Verify -> Evolve loop, and one explicit governance boundary instead of a generic chat preset.
Deterministic intake envelope
After submit, the API immediately returns the intake ID, lane, source, receivedAt, consentAt, a normalized summary, the first provisioning trail, readiness states for auth, entitlements, billing, and activation, and a status/resume path so activation continuity survives beyond one browser session.
Launch artifacts + continuity
The app renders the provisioning capsule from the same runtime contract, then composes a compact activation handoff packet and a first mission launch packet so continuity, boundary, launch gate, and first outcome stay inspectable.
The first runtime should prove value immediately: one governed delivery, one receipt trail, and one success signal you can verify in the first week.
Template
The runtime starts from a concrete mission template instead of a vague assistant prompt.
First delivery
The first activation should return a real brief, follow-up queue, or monitored perimeter the operator can use immediately.
Receipts
Signals, queued actions, approvals, and outcome checks stay attached so the work remains inspectable.
Success signal
The first week should measurably reduce operator reconstruction, not just promise future automation.
This lane is intentionally narrow. The first runtime is for operators with one repeatable mission where memory, governance, and execution immediately change the outcome.
Who it is for
Founders, deal operators, research operators, and small teams with one mission that benefits from governed personal agency immediately.
What to prepare
One model lane, three world sources or fewer, one governance mode, one execution boundary, and one mission with a real operating cadence.
How activation moves
Intake returns immediately, runtime scoping and governance review happen in the first operator review window, and activation starts only after reviewed provisioning.
What comes back first
Deterministic intake envelope, Digital World Model boundary, decision loop, governance boundary, provisioning capsule, activation handoff packet, first mission launch packet, activation package, launch checklist, and the first mission queue instead of a vague waitlist state.
What becomes yours
One bounded World Model workspace, one governance profile, one receipt surface, and one replaceable model layer instead of a provider-locked chat thread.
A $20 model subscription gives you intelligence. It does not give you a governed personal agent.
- No persistent World Model that understands your people, priorities, commitments, and operating context.
- No audit trail. You cannot inspect why a follow-up, schedule change, or decision was made last Tuesday.
- No durable policy boundaries. The model can suggest things, but it does not live inside your rules.
- No proactive execution loop across sessions. The intelligence resets the moment the chat ends.
- No portability. The platform owns the layer that matters, not the individual who needs the agent.
Signals, world state, and tool context.
Goals, policy, and priority before action.
Approved execution through tools and APIs.
Receipts, outcomes, and state confirmation.
Memory updates that improve future decisions.
A structured operating memory for you and your agent.
People, tasks, obligations, signals, risks, metrics, and decisions live in one graph that compounds over time. Your agent stops guessing from the latest prompt and starts acting from the world it actually knows.
People, goals, obligations
Your agent understands who matters, what is due, and what must not fall through the cracks.
Signals, deadlines, metrics
Operating context stays live, so the agent can notice changes instead of waiting for a new prompt.
Decisions and receipts
Actions, approvals, and outcomes remain traceable, so the agent becomes auditable instead of opaque.
Memory that compounds
Every cycle makes the World Model sharper. The value stays with you even if the model provider changes.
Every action passes through policy, approval, and verification before execution.
ODEI enforces your rules architecturally, not as soft prompt suggestions. Guardian layers validate writes, block unsafe operations, and leave an inspectable receipt trail so the agent can act without becoming a black box.
Approval lanes
Choose what the agent can do autonomously and what still requires your sign-off.
Write-time validation
World Model updates are checked before they land, so low-quality context does not silently poison the runtime.
Receipts and audit trail
Every decision, action, and rejection carries provenance, timestamps, and state so you can inspect what happened later.
Portable architecture
Claude, ChatGPT, Gemini, or the next frontier model can sit on top. The memory and governance layer remain yours.
The guided launch is for high-value repeated work where memory, governance, and execution change the outcome immediately.
Keep the operating brief and investor thread moving
Your runtime notices silent threads, assembles the weekly operating brief, and keeps follow-ups moving with full context instead of manual reminders.
- Inbox triage and follow-ups with context already loaded
- Weekly operating brief generated from live sources
- Decision trail preserved with receipts
Protect timing on pipeline and counterparties
The agent tracks engagement, notices silence, and prepares the next touch with the actual deal context, not a generic CRM reminder.
- Silent thread detection across email and calendar
- Follow-up drafts tied to the real state of the deal
- Receipts for every outbound action and approval
Monitor a fixed perimeter without losing signal
Your runtime watches a bounded research surface, updates the World Model, and delivers a brief when something materially changes.
- Receipt-backed monitoring and synthesis
- Context retrieval across sources and sessions
- Only meaningful changes escalate into briefs
One shared World Model, governed by the team
Start with one shared runtime, clear approval lanes, and execution receipts so the team stops losing context between people, tools, and sessions.
- Shared memory across people, tasks, and priorities
- Governed operator lanes for different team roles
- First mission launched on top of the same team context
You already pay for the model. ODEI charges for the personal layer that makes it useful.
Setup
One-time onboarding for your World Model, governance rules, connected tools, permissions, and first operating missions.
Monthly runtime
Persistent memory, hosted loop execution, policy enforcement, receipts, and continuity across sessions.
Usage-based execution
Heavy model calls, browser actions, paid routes, and external API costs scale with real work instead of idle seats.
Bring your own model or use ODEI credits. The point is not to buy another chatbot. The point is to run a governed personal agent on top of the intelligence you already use. Guided-launch onboarding already captures activation preference and billing readiness before self-serve checkout opens, and the billing boundary is already published as a machine-readable contract.
Replace manual work with 24/7 operations
Every cycle of the operational loop is work you used to do yourself or pay someone else for. Monitoring, reporting, follow-ups, pipeline management — your agent handles it around the clock.
Pipeline and follow-ups stop stalling
Your agent notices silence, prepares replies, updates briefs, and keeps revenue lanes moving with full context and verification instead of ad hoc reminders.
Structured intelligence compounds over time
Every day your Digital World Model grows more valuable. Patterns, relationships, decisions — structured knowledge that gives you a compounding competitive advantage no competitor can copy.
Keep the model you already use. ODEI lives underneath it as memory, governance, receipts, and execution infrastructure.
Launch your personal agent on your own stack.
Use Codex, Claude Code, or Gemini to launch ODEI on your machine. Keep Claude, ChatGPT, Gemini, your own API key, or ODEI credits as the model lane. Create your world locally, then let the loop run with memory, governance, and receipts that remain yours.