Your AI can do more than chat.
Give it your World Model
and unleash its full power.

Every fact about you lives as a node in a graph database on your machine: a goal, a rule, a person, a decision, a deadline. Your sessions read it for context and write back through a governed gateway. The result is memory with structure. Not a pile of transcripts: a model your agent can reason over, query, and defend.

• A personal knowledge graph runs inside the ODEI desktop app, backed by Neo4j on your machine. Five domains organize your world: Command, Track, Build, Protect, Network
• Visual explorer in 2D and 3D with domain, kind, and status filters. You see your model the way your agent sees it
• Governed writes: high-risk changes go through a propose, decide, apply gate with entity and relationship validation. No silent edits, ever
• Atomic sessions, certified end-to-end with five permanent CI guarantees: cold-restart recall, mid-stream-kill durability, exactly-once persistence, strict session isolation, and sleep-wake survival
• Three layers of persistence under every conversation: a structured history store, the provider's native log, and a session manifest. Reopen a session and the model genuinely remembers: it answers from memory, not from re-reading files
• The living proof on this site: the homepage sphere renders a real World Model, live

• Automatic capture: your sessions mine themselves into the graph, so the model builds itself while you work
• Audit timeline on every fact: where it came from, when it changed, one tap to revert
• Portability: export and move your model. Any AI can think with it. None can take it

Each connector is a contract, not a firehose. See means observe only. Ask means request access each time. Auto means a standing grant inside limits you set. Every pipe into your model is visible on one map, and every pipe can be closed with one tap. Context without surveillance.

• On-chain senses are live: the runtime reads wallet state and market data feeds in real time
• The web surface verifies holder status against the Base chain on every session: a working example of a Sense with provenance

• Six connectors, Telegram first: then Gmail, Google Calendar, Apple Health, Notion, and Money on Base
• Per-connection dial: See, Ask, or Auto, set per source and changeable any time
• Data-Flow Map: a live view of exactly what enters your model, from where, and why
• One-tap revoke on any source, with the full trail kept in your audit timeline

Powers are scoped grants, not god mode. Policy lives in your World Model; the runtime checks it before any action executes. In the desktop runtime this is already physical: a surface cannot call tools outside its grant, no matter what the model decides. Governance is not a promise in a settings page. It is the architecture.

• Per-surface tool gating is enforced in the runtime: money-moving tools are physically blocked from the chat surface
• High-risk World Model writes require a proposal and an explicit decision before they apply
• Entity and relationship validation on the write gateway: malformed changes never land

• Scoped grants: what your agent may do, where, with what budget, until when
• Ask-first mode for anything outside standing policy, with one-tap approve in chat
• Signed action receipts: what was done, when, and under which rule
• Instant revoke of any power without breaking the rest of the runtime

A loop is a standing intention: watch this, do that, report back. The runtime instruments the full governance cycle, Observe, Decide, Act, Verify, Evolve, and scores its coverage live. When loops go autonomous, every run will land as a card: what triggered it, what it did, what it cost.

• The governance loop is instrumented: a live telemetry view scores agent activity across all five phases
• Atomic session continuity makes long-running work survivable: stop tonight, resume tomorrow, nothing lost

• Scheduled routines: reports, digests, follow-ups that fire on your calendar, not your attention
• Watchers: standing observers on mail, markets, health, deadlines that wake your agent on signal
• Run-cards: every loop execution gets a card with inputs, outcome, and cost
• Loop results write back into your World Model, so the agent gets smarter every cycle

Voice is the same agent and the same memory, in conversational form. No separate chatbot with separate amnesia: the conversation reads your World Model, speaks in your shorthand, and never asks you to re-explain your life. The cloud workspace already runs real threads with quotas and holder access; the messengers you live in come next.

• The operator conversation is the product: the Commander desktop runs three agents side by side, Claude Code, Codex, and Gemini, on one shared World Model
• ODEI Talk, the cloud workspace, is built end-to-end: persistent threads, usage quotas, holder access tiers. It runs in invited preview today

• Public Talk launch: your agent in the browser, no install required
• Telegram, WhatsApp, and X as first-class surfaces: your agent in your pocket
• Voice notes in, structured action out: speak a thought, get it filed, scheduled, or done

Money becomes an ability instead of a risk when limits are signed. The runtime separates seeing money from moving money: snapshots and prices are free senses; mutations are gated powers. Below your signed allowance, payments flow on autopilot. Above it, nothing moves without your signature on your device.

• The runtime carries a finance module: wallet snapshots, on-chain action requests, and state, physically gated away from the chat surface
• Holder verification runs live against Base on the web surface, with a five-tier access ladder enforced at login
• Agent Passport on Base: your agent gets an on-chain identity you connect from your profile

• Budgets you sign: per-day, per-action, per-counterparty limits on the agent wallet
• Micropayments on autopilot via x402: your agent pays for what it uses, within its allowance
• Everything above the limit asks for your signature on your device, every time
• Session keys as revocable, auditable on-chain guardrails

One model, many minds. Three different AIs already think with the same World Model in the desktop runtime: what one learns, the next can use. Coordination extends that from models to actors: your agent delegates to other agents, negotiates with humans, and files every outcome back into the world you own.

• Three operator agents share one World Model in the desktop runtime: Claude Code, Codex, and Gemini, interchangeable without context loss
• Agent-assisted onboarding: your CLI agent can conduct your registration with a pairing code, agent to agent

• Agent-to-agent jobs: delegate work to other agents under your policy and budget
• Scheduling and negotiation with humans on your behalf, in your tone, within your rules
• Outcome capture: agreements, dates, and deliverables write back into your World Model
• Network effects with sovereignty intact: collaboration without surrendering your data