The Exocortex Architecture
Hobbes is a Context Composition Engine, not a Chatbot. In experimenting with AI, we found that frontier models could handle quite a bit of "workflows" natively, when you treat context as something precious to the chat outcomes. Hobbes maintains a living "Short-Term Memory Object" that allows your chat to continue naturally as long as it takes to get the outcome you need.
The Exocortex leverages a local-first SQLite and JSON Store architecture, ensuring your data never leaves your machine.
Instead of a simple chat log, Hobbes maintains a "Memory Object". This object is a living, composed context updated by a background Summary Model (Gemini 3 Flash Preview). This allows for infinite context retention on relevant topics without blowing up the token window or losing the thread.
AI is delivering on the original dream of computing: the ability to speak to a machine in our own language and have it understand. While programmers have always given computers complex instructions, AI makes this power accessible to everyone. Hobbes makes it safe to connect this new capability to the tools and apps you use every day.
Architectural Learnings
Cognitive Translation
The Semantic Bridge
The challenge of building a trustworthy AI assistant begins with a fundamental translation problem: enabling nuanced, multi-domain communication between user intent and context-sensitive model behavior.
- •Type-Safe Schema Conversion
- •History-Grounded Error Correction
- •Turn Re-Inversion
Context Orchestration
The Memory Engine
Building an AI assistant that remembers across sessions requires more than simple state management. It demands a sophisticated orchestration system that preserves the right information while discarding the noise.
- •Reactive Session State
- •Background Summarization
- •Tool Call Snapshotting
HITL by Design
The Trust Architecture
The Human-In-The-Loop philosophy is not an afterthought in Hobbes; it is the foundational architecture that makes everything else possible. You need to trust your agent, and trust requires your ability to control it.
- •Unified Permission Lifecycle
- •Explicit Tool Approval
- •Transparent Tool History
Cognitive Translation
Cognitive Translation
The Semantic Bridge
Speaking Both Languages
Every MCP tool defines itself using its own schema dialect, and the LLM expects something different. Hobbes acts as a conversion layer between them, walking each tool's JSON Schema recursively, mapping types into the model's native format, and namespacing tool identities so servers can't collide. If a tool can't be cleanly translated, it gets skipped with a warning instead of crashing the whole pipeline.
When Schemas Don't Agree
Connect enough tool servers and you'll run into naming collisions, unsupported types, and schema shapes the model was never designed for. Loose JSON parsing hides these mismatches until they show up as silent failures at runtime.
Let the Compiler Be the Gatekeeper
The conversion passes through typed Rust structs, not string manipulation. If a schema is well-formed, it compiles. If it's not, the type system catches it before it ever reaches the model. What comes out the other end is a prompt that only contains tools the LLM can actually use, assembled alongside history and system instructions with API limits enforced automatically.
Context Orchestration
Context Orchestration
The Memory Engine
Idle Time Is Thinking Time
Three systems run concurrently. Session state propagates reactively through the UI. A background scheduler watches for pauses in the conversation, and when you stop typing, it starts summarizing. Tool interactions get snapshotted so the full state of every external call is preserved alongside the dialogue.
Conversations Have a Half-Life
Long conversations collapse. The model loses earlier details, session handoffs break continuity, and tool interactions vanish from context. The longer you work, the less your assistant actually remembers.
Structured Memory, Not Scrollback
The session holds layered state: persona, instruction, tools, and an extensible metadata map. When you're idle, a background process distills the full conversation into a structured summary with sentiment and entity extraction. The next prompt starts with that understanding already loaded, so starting fresh or picking up where you left off feels the same.
HITL by Design
HITL by Design
The Trust Architecture
Default Deny
Permissions cascade through three tiers: global toggle, category, and per-server. At every gate, the default answer is "ask the human." You opt in to autonomy; it's never assumed. This lets the system scale from careful first use to confident daily operation without changing the underlying architecture.
Autonomy Without Audit
When an AI agent modifies files, makes API calls, or accesses data without your knowledge, trust degrades with every surprise. And when something goes wrong, having no audit trail makes recovery a guessing game.
The Stream Stops
When the model requests a tool that hasn't been pre-approved, the execution stream pauses. It's a hard stop, not a soft warning. An approval prompt shows the tool name and server, with approve and deny buttons. The decision is recorded. The model waits. You act, or it doesn't.
We found context to be something to be orchestrated. The system's Memory Object Architecture enables it to understand not just what you've discussed, but when, why, and how it connects to your broader goals.
This creates a living memory that evolves with each interaction, building a cumulative understanding that traditional RAG systems simply cannot achieve. When combined with dedicated long-term MCP memory storage for the agent, each session can quickly gain the context it needs to get you back on track. Starting fresh or with the memory of a previous session.
Every time we've onboarded a new partner to early testing, we've gotten to enjoy them light up with the joy and surprise of using an AI that's properly and securely grounded in facts. We'll keep working on making Hobbes better. We hope you enjoy being more productive.
3 months
Time to MVP
6 Months
Project Duration
1 Dev + AI Pair
Team Size
~90%
AI Code Generation
100%
Human In the Loop
6 Months to v0.9
Time to Completion