Product Specification — MERIDIAN Sovereign Build

What They Walk Away With

The client receives a fully operational sovereign AI system. Not a concept. Not a set of prompts. Not an API key. A running system on hardware they own, configured to their life, with a mobile app in their pocket.

Deliverable	What it is	Format
The Machine	Hardware configured and running. Either their existing machine upgraded or a dedicated mini server (Mac Studio, custom build, etc). Offline-capable models loaded and tested.	Physical hardware, shipped or configured onsite
The Intelligence	Their personal AI agent — identity configured, knowledge bank seeded, integrations live. This is the brain.	Software stack, installed and running
The Interface	A private app on their phone + desktop. Chat, voice, quick capture. Their AI is always accessible — as natural as texting.	PWA (works offline, installs like native app)
The Architecture Brief	Bound physical document. Their complete intelligence architecture — domains mapped, integrations documented, evolution protocol defined.	Printed, bound, hand-delivered
The Knowledge Bank	Their first 50-200 documents/conversations/books ingested and searchable. The foundation of their personal intelligence.	Vector database, queryable from the agent
The Integrations	Every tool they use, connected. Calendar, email, health trackers, financial tools. The system sees everything.	Live API connections, tested and monitoring
The Training	2-hour hands-on session. How to talk to it, how to feed it, how to correct it, how to evolve it. Not a manual — a session.	Live, recorded for reference

System Architecture

This is the file structure of a delivered sovereign build. Every client gets this. Customized to their domains, their data, their integrations.

sovereign/ ├── agent/ # The intelligence layer ├ ├── core.py # Main agent — processes all input, routes to domains ├ ├── SPINE.md # Agent identity — who it is, how it thinks, its principles ├ ├── RAM.md # Rolling context — updated after every session ├ ├── llm.py # Model interface — swappable between local + cloud ├ └── tools.py # Agent tools — search knowledge, check calendar, etc. ├── knowledge/ # Personal knowledge bank ├ ├── store.py # Vector database (LanceDB) — all embeddings ├ ├── query.py # Retrieval — semantic search across all knowledge ├ ├── ingest.py # Pipeline — PDF, audio, email, any format → vectors ├ └── knowledge.db # The database itself — all their knowledge as embeddings ├── domains/ # Domain-specific modules ├ ├── health/ # Biological intelligence ├ ├ ├── tracker.py # Pulls from wearables (Whoop, Oura, Apple Health) ├ ├ ├── bloodwork.py # Parses lab results, tracks biomarkers over time ├ ├ └── correlator.py # Connects sleep/HRV/cortisol to decisions + performance ├ ├── operations/ # Business + life operations ├ ├ ├── calendar.py # Google/Outlook sync — reads, flags, suggests ├ ├ ├── email.py # Email processing — summarize, prioritize, draft ├ ├ └── finance.py # Financial data feeds — accounts, transactions, patterns ├ └── evolution/ # Self-learning layer ├ ├── patterns.py # Learned behavioral patterns over time ├ └── feedback.py # Correction history — how the agent improves from use ├── interface/ # How they interact with it ├ ├── app.py # Web app — serves the chat + dashboard UI ├ ├── voice.py # Voice interface — speak to the AI, get spoken responses ├ └── static/ # PWA assets — installs on phone as native app ├── models/ # AI models — local + optional cloud ├ ├── config.yaml # Which model for which task — cascade order ├ └── local/ # Downloaded models (Qwen, Llama, etc) — runs offline ├── security/ # Encryption + access control ├ ├── encryption.py # At-rest encryption for knowledge bank + config ├ └── access.py # Who can use the system — PIN, biometric, family ACLs ├── .env # API keys — encrypted, never leaves the machine └── start.sh # One command — the whole system boots

Key point: This is not a monolith. Every module is independent. If they don't want financial tracking, that domain doesn't exist. If they want to add a domain (e.g. investment analysis), it plugs in without touching anything else. The architecture is additive.

What It Actually Lets Them Do

Not features. Capabilities. Things they can do on Day 1 that they couldn't do before.

Talk to it like a person who knows everything about them

"What did I decide about the London deal last March and why?" — it answers from actual context. "My sleep has been bad this week — should I take the meeting with the investors tomorrow?" — it correlates their HRV data with their decision history and gives a real answer. Not a chatbot. A mind that has context.

Capture everything, lose nothing

Voice note on a walk → transcribed, tagged, stored in their knowledge bank, retrievable forever. PDF from their accountant → ingested, key points extracted, available as context for future financial decisions. Book they read → principles extracted, linked to their existing knowledge. Every insight compounds instead of being forgotten.

See patterns they can't see

The system correlates across domains a human brain can't hold simultaneously. "Your creative output drops 40% in weeks where you have more than 3 evening commitments." "You've made your 4 worst investment decisions in the 48 hours after international travel." "Your cortisol has been elevated every Tuesday for 6 weeks — the board meetings are costing you more than you think."

Operate with full context

Before a meeting: the system surfaces everything relevant — past conversations with that person, related decisions, relevant knowledge, their own notes. Before a decision: it shows how they've handled similar situations before and what happened. No human advisor can hold this much context. The system holds all of it.

Run completely offline

Airplane. Remote cabin. Paranoid about data. Doesn't matter. Local models run on the hardware they own. No internet required. No cloud dependency. No third-party access. Pull the ethernet cable — it keeps working.

Hand it to their children

Access controls let them grant family members access to specific domains. Their teenager can query the knowledge bank for advice grounded in decades of their parent's actual thinking. Not a quote from a book — a response built from real decisions, real context, real evolution.

Product Level — What Makes This $100K

The difference between this and "someone setting up ChatGPT for you":

Generic AI setup	Sovereign build
Uses someone else's servers	Runs on hardware you own
Your data trains their models	Your data stays on your machine
Forgets between sessions	Remembers everything, forever
Same system as everyone else	Built for one person: you
No domain integrations	Calendar, email, health, finance — all connected
Text interface only	Phone app + voice + desktop — always accessible
No learning over time	Gets smarter every day for decades
You adapt to the tool	The tool adapts to you
You can subscribe for $20/mo	Your grandchildren inherit it

The quality bar

The interface must feel as natural as iMessage. If it feels like a developer tool, we failed.
The knowledge bank must return relevant results within 2 seconds. If it's slow, they won't use it.
The integrations must just work. No manual syncing. No "check back tomorrow." Real-time or near-real-time.
The voice interface must feel like talking to a sharp person, not a robot. Low latency. Natural speech.
The system must boot with one command. If it takes 5 steps to start, they'll stop using it.

How We Deliver

The full build takes 4-6 weeks from signed engagement to operational system. Here's the delivery sequence.

Pre-Audit Prep (Week 0)

Client fills out a pre-audit questionnaire. What tools they use, what health trackers they wear, what devices they own, what they want the system to do first. We configure hardware and download models before we fly out. We arrive ready to build, not ready to plan.

The Onsite Audit (3 days)

Day 1: Full biological baseline. Blood work ordered. Wearable data pulled. Sleep, HRV, cortisol patterns analyzed. Sam runs the somatic assessment.
Day 2: Business + life audit. Calendar forensics. Email patterns. Financial tools. Knowledge audit — what books, what conversations, what documents matter. Security requirements.
Day 3: Architecture session. Walk through the proposed system with the client. What domains. What integrations. What the interface looks like. Adjust based on their input. Begin hardware configuration.

The Build (Week 1-3 post-audit)

Q builds the system remotely. Agent identity configured. Knowledge bank seeded with their first corpus (50-200 documents). Integrations connected and tested. Interface deployed. Models calibrated. Client gets async progress updates and can start using the system from Week 2.

The Architecture Brief (Delivered Week 3)

Bound physical document shipped to client. Complete architecture — every domain, every integration, every data flow, every evolution protocol. This is theirs forever. If they ever switch providers (they won't), this document tells anyone what was built.

Handoff + Training (Week 4)

2-hour live session. How to talk to the system. How to feed it new knowledge. How to correct it when it's wrong. How to add family members. How to use the mobile app. How to run it offline. Recorded so they can rewatch.

First Evolution Check (Week 6)

30-minute call. How's the system working? What's surprising them? What needs adjustment? First corrections applied. First pattern analysis reviewed. This transitions into the ongoing retainer rhythm.

Product Development Roadmap

What we build internally so that each successive client gets a better product faster. This is the production function — the thing that makes client 5 take half the time of client 1.

Phase	What we build	Outcome
Client 1 NOW	Build the entire system from scratch for one person. Every line of code. Every integration. Every decision made live. Document every choice.	Working product. Battle-tested architecture. Real delivery process. First case study.
Client 2-3	Extract the reusable core from Client 1. Template the agent identity setup. Template the knowledge ingestion pipeline. Standardize the interface. Build deployment scripts.	50% faster delivery. Repeatable process. Internal toolkit.
Client 4-6	Build the domain marketplace. Pre-built health, operations, and financial modules that plug in. Client gets a base system + picks their domains. Build the admin dashboard for ongoing management.	3-week delivery. Modular architecture. Clients can request new domains post-build.
Client 7-12	Build the family layer. Multi-user access controls. Shared knowledge with privacy boundaries. The inheritance protocol. Build remote monitoring for retainer clients (system health, usage patterns).	Full product. 2-week delivery for standard builds. Family builds as premium tier. Retainer management at scale.

The key insight: We don't build the full product then sell it. We sell Client 1, build for them, extract the reusable parts, and each client makes the product better. Client 1 pays for a custom build. Client 12 gets a refined product that took 12 builds to perfect — and it's still custom to them.

What We Need Before Client 1

Not everything. Just enough to deliver on the promise. The rest we build during and after the first engagement.

Component	Status	Work needed
Agent core (SPINE + RAM + tools)	Built	Exists in VOHU MANAH. Needs to be made portable — extract the pattern into a template that can be configured for any person.
Knowledge bank (LanceDB + ingest + query)	Built	Exists in TAO. Ingestion pipeline handles PDF, text, audio transcripts. Needs cleanup for client deployment — remove Metatekt-specific code.
LLM interface (local + cloud)	Built	core/llm.py handles model routing. Needs config-driven model selection per client (their hardware, their preferences).
Mobile interface (PWA)	Partial	Dashboard exists. Needs a clean chat interface + voice input. 2-3 days of work. Standard web tech — no app store needed.
Health domain	Partial	Need API connectors for Whoop, Oura, Apple Health. Blood work parser needs to handle common lab formats. 1 week.
Calendar + Email integration	Not built	Google Calendar API + Gmail API. Standard OAuth flow. 3-4 days.
Financial integration	Not built	Depends on client's tools. Plaid for bank data, or direct API to their accounting software. Build per client.
Voice interface	Not built	Whisper for STT, TTS for output. Can use local Whisper on their hardware. 2-3 days.
Security layer	Partial	Need at-rest encryption for the knowledge bank and .env encryption. Access control for family members. 2-3 days.
One-command boot	Built	start.sh pattern exists. Needs to be made portable.

Honest assessment: 70% of the system exists in VOHU MANAH. The remaining 30% is integration work (APIs to external services), a clean interface, and portability (removing Metatekt-specific code). We can deliver Client 1 within 6 weeks of signed engagement. Not because everything is perfect — because the core is proven and the rest is standard integration work.

The Output That Matters

Forget features. These are the outputs that determine whether the product delivers on the promise.

Output	Measure	Target
Daily usage	Does the client open the app every day?	7 out of 7 days in the first month
Knowledge depth	How many documents in the bank after 90 days?	500+ nodes ingested
Pattern detection	Has the system surfaced a non-obvious correlation?	At least 1 in the first 30 days
Decision quality	Has the client referenced the system before a major decision?	Yes, within 60 days
Retainer renewal	Does the client stay on retainer after Year 1?	100% of clients
"Show someone" moment	Has the client shown the system to a friend/colleague?	Within 90 days — this is how Client 2 finds us

The ultimate test: If the client's system broke tomorrow and they couldn't use it for a week, would they feel it? If the answer is yes, we delivered. If the answer is no, we built a toy.