01
Memory that compounds
Nebula keeps the context you should not have to repeat, then turns it into a long-term advantage you own.Under the hood: episodic, procedural, goal, preference, world, and receipt stores.
The Point
Not another chatbot. The layer your AI has been missing.
Chatbots answer and forget. Nebula keeps memory, tools, voice, background work, and every interface connected to a private core you control.
02
Work you can audit
When Nebula acts, it leaves proof: what happened, why it happened, and where the boundary was.Under the hood: action runs, postconditions, idempotency, and audit trails.
03
One core, every screen
Phone, web, voice, push, and desktop all point back to the same owned intelligence layer.Under the hood: backend-owned state contracts, not app-specific memory silos.
04
You decide what leaves
Use local models when privacy matters. Use APIs when speed or cost wins. Either way, your long-term memory stays with you.Under the hood: egress allowlists, private gates, and explicit routing policy.
05
Autonomy with a conscience
Nebula is built to do useful background work without pretending every action should be automatic.Under the hood: wake/sleep loops, reversible work, approvals, and loop brakes.
06
Still early. Already real.
The foundation is running now. The next push is the daily product: home, money, goals, inbox, Android, and voice.Under the hood: Web UI v2, usability APIs, STT/TTS lanes, and health observability.
For Humans And Builders
Built for normal life. Honest enough for technical trust.
The goal is not a shinier chat box. The goal is an owned layer that can help with reminders, money awareness, goals, research, workflows, and home operations while showing what it knows, what it did, and what it refused to do.
Plain-English promise
- It remembers context you should not have to repeat.
- It helps run the day, not just answer a prompt.
- It is designed to ask before irreversible actions.
- Your private history stays under your control by default.
Technical promise
- One backend source of truth, not scattered app memory.
- Auth, LAN guards, loop brakes, and outbound-control rules are built in.
- Memory, goals, inbox, actions, and health are stored in a way you can inspect.
- Models are swappable: local Qwen/Gemma-class gates, DeepSeek V4 Flash, or other API lanes by policy.
Architecture
A COS, not a wrapper around a model.
The model is only one part. Nebula adds the owned memory, rules, tools, voice, health checks, and interfaces that make intelligence compound over time.
Surfaces
Android, Web UI v2, voice, push, desktop, and future clients all read from the same source of truth.
live plus landing
Usability
Home, Inbox, Goals, Money, reviews, opportunities, and controls turn the system into something you can use daily.
active track
Cognition
Reflection, self-checks, computer use, and proof gates help Nebula improve without becoming reckless.
gated
Memory
Long-term context for episodes, habits, goals, skills, preferences, world state, and receipts.
live
Security
Outbound-control rules, sanitization before helpers, auth by default, privacy labels, and action receipts.
core
Models
Local Qwen or Gemma-class private gates, plus DeepSeek V4 Flash or other API lanes when cost, speed, or hardware limits matter.
swappable
Proof, Not Theater
The hard parts are already becoming real.
Nebula is early, but it is not a Figma dream. The backend, Android app, voice stack, and usability contracts are being built as one system, with honest gates where the proof is not finished yet.
The brain is not the app
Memory, goals, inbox, actions, approvals, and evidence live in the backend so Android, web, voice, and desktop can all render the same truth.
Under the hood: usability kernel, Home composer, Inbox conversion, ActionRun receipts, and typed surface contracts.A real mobile surface
The Android app is not a placeholder. It has Nebula Core presence, runtime truth, voice state, connection state, and contract-aware client code.
Under the hood: NebulaPresenceMapper, NebulaCore, authenticated client calls, debug truth surfaces, and v1.88 LiveKit readiness gates.Voice is gated on proof
Parakeet STT, OmniVoice, Kokoro, websocket voice, and LiveKit work exist, but Nebula does not pretend the phone-room proof is done before it is.
Under the hood: STT/TTS lanes, barge-in controls, LiveKit capability checks, fallback transport, and phone acceptance gates.Useful beats impressive
The next layer is not more demos. It is Home, capture, goals, money, opportunities, reviews, and approvals turning the system into a daily habit.
Under the hood: backend-owned life model, domain cards, evidence-backed insights, review loops, and surface-ready APIs.Models think. Nebula remembers, decides, acts, and shows its work.
The Difference
Generic companions perform personality. Nebula runs continuity.
The market is filling up with friendly avatars and chat memory. Nebula is built around the harder thing: durable state, owned data, real tools, deliberate boundaries, and evidence that survives the session.
- A persona on top of a chat model.
- Memory is a feature inside someone else's cloud.
- Actions are often hidden, simulated, or disconnected from receipts.
- The app owns the experience. The provider owns the center of gravity.
- A user-owned layer around models, tools, voice, and memory.
- Long-term state lives in memory and receipts you control.
- Actions pass through rules, checks, and audit trails.
- Models are replaceable parts: local, hybrid, or API-backed by choice.
Reality Check
Not product-ready yet. Not vapor either.
This is the current shape as of May 16, 2026: infrastructure is deep, the usable product layer is landing, and several public-preview gaps are still intentionally visible.
Live now running
- Private backend with auth, LAN/browser guards, outbound controls, sanitizer, and receipts.
- Web UI v2 shipped under `/v1/web/v2` with graceful empty states.
- Home, Inbox capture/conversion, and Goals APIs are live enough to wire into real product screens.
- Parakeet STT, Kokoro and OmniVoice response lanes, world-library FTS, health observability, and LiveKit backend work exist.
Landing next active
- Home cards need real sources of data so the first screen feels alive.
- Money is planned as a read-only cockpit: balances, transactions, subscriptions, and insights.
- Goals check-ins, reviews, opportunities, and better Android Home are queued.
- Privacy dashboard, outbound log viewer, and data export should become product-visible.
Still hard honest
- Setup is still for technical users with Docker, STT/TTS services, the harness, model/API keys, OAuth, and local infrastructure comfort.
- Voice works architecturally, but the real phone-room smoke test is still a pending gate.
- Some large legacy functions and dispatch chains still need cleanup before broad product pressure.
- Nebula is not a hosted SaaS. API mode can use data centers for inference, but the user still owns the memory, config, receipts, and state.
Product Experience
One private core, many windows.
A chat answer is only one output. The real product is the daily loop: Home shows what matters, Inbox captures loose ends, Goals track why work matters, Money watches for drift, and Live shows what Nebula is doing instead of hiding automation behind magic.
Deployment Modes
One owned harness, different hardware paths.
Nebula should not require one perfect machine. The important part is the private harness that holds your memory, rules, tools, and receipts. The model can be small and local for private routing, or it can call a cheaper API like DeepSeek V4 Flash when you choose to trade some cloud use for speed and cost.
A
Full local
Run everything at home: the Nebula harness, Parakeet STT, Kokoro or OmniVoice TTS, and a local main model such as Qwen when the hardware can carry it.
B
Hybrid API
Keep memory, tools, policy, STT/TTS, and the harness self-hosted, while sending only selected reasoning calls to DeepSeek V4 Flash or another API.
C
Private gate
Use a smaller Gemma E4B-class local model as the front door: it routes, classifies, and checks privacy before anything is allowed to use an API.
The Difference
Why not just use ChatGPT, Claude, or Gemini?
You absolutely should. But your life shouldn't be trapped in their context window. Nebula is your private foundation—store your memories safely at home, and only route the hard questions to the cloud when you choose to.
Cloud Chatbots (ChatGPT, Claude)
Brilliant at answering questions, but they suffer from amnesia. You rent their memory, and your private life becomes training data. Nebula keeps your continuous life story securely on your own hardware.
Terminal Tools (Open Interpreter)
Incredible for executing local code, but they are reactive tools waiting for a command. Nebula is a proactive companion with background loops that works while you sleep.
Smart Home Hubs (Home Assistant)
The gold standard for turning on your lights and managing hardware. Nebula manages your life—tracking your goals, watching your money, and managing your inbox.
Memory Frameworks (MemGPT)
Great architecture for long-term context, but memory is only one piece of the puzzle. Nebula wraps memory in secure actions, real-time voice, and beautifully designed user interfaces.
Roadmap
The next level is usefulness, not more architecture diagrams.
Nebula's infrastructure phase proved the stack can exist. The next sprint proves it can become a habit.
Make Home matter
Wire real data into Home: due tasks, approvals, watch matches, reminders, money pulse, and a morning brief that actually knows the day.
Turn capture into trust
Inbox should accept voice, text, file, and web captures, then convert them into tasks, reminders, notes, watches, and goals with receipts.
Ship the first money moment
Read-only Plaid sync, subscriptions, anomalies, and "you forgot this" insights are the fastest route from interesting to valuable.
Make privacy visible
Show data inventory, outbound logs, domain toggles, helper receipts, and export controls so users can see the privacy model instead of trusting a promise.
Reduce setup friction
Move from enthusiast infrastructure to a clear Docker-first setup path with model configuration, OAuth, and optional integrations explained plainly.
Amplify Your Productivity
Ready to own your intelligence?
Nebula massively amplifies your productivity by working autonomously in the background. It is completely yours, completely private, and runs exactly how you want it to. Choose how you want to get started.
Self-Hosted / DIY
For the technical, privacy-aware power user. Deploy the entire cognitive operating system to your own hardware using our open architecture.
View on GitHub
Pending
Done-For-You Setup
Skip the infrastructure headaches. I will personally deploy, configure, and secure the entire Nebula OS specifically for your needs. Currently waitlisting.
Join the Waitlist