Jason Kessler

Nexus — AI Agent Infrastructure — one brain, every surface

Problem: Every AI session starts from zero. Close the window and the decisions, the reasoning, and the hard-won context are gone — you re-explain, work repeats, and nothing compounds. Add more channels and it gets worse: messaging, web, and voice each become their own siloed agent holding its own partial picture.

Approach:

• One persistent brain. A messaging channel, the web dashboard, voice (including a desk robot) and the terminal are all surfaces over the same memory, tools and skills. Move from texting to typing to talking mid-conversation; nothing resets.
• Hand it a case number. No explaining, no setup. The system retrieves case history, surfaces past root causes for similar symptoms, runs the investigation protocol, and writes the findings — automatically.
• Models by role, not by name: small local models classify, triage and embed beside the data; a frontier model does the reasoning. Which model fills a role is decided by measurement — a cheaper one has to win a blind side-by-side first.
• Hand it a directive over text — 'reply to the vendor,' 'shop insurance brokers' — and it closes the loop: drafts in the right voice, watches for replies, weighs them against a baseline, and texts back a recommendation. Delegation is governed: routine follow-ups on a matter I started go out on their own; money, legal filings and any escalation wait for my approval.
• Memory that doesn't forget — episodic, semantic, procedural — typed, weighted, queryable. Every interaction across every surface feeds it, and each session ends by distilling what's worth keeping into memory — automatically.
• Not every agent gets the keys. A second assistant, outside the trust boundary, connects through a scoped MCP gateway that hard-codes what it can see — a single domain of distilled findings, create-only writes, a receipt on every capture. Least privilege, applied to agents.

Impact: An assistant that doesn't start from scratch and isn't tied to a single screen — and that acts, not just answers. Every session builds on the last; every channel is a window into the same coherent agent.

Stack: Python, FastAPI, FastMCP, PostgreSQL, pgvector, Redis, Model gateway, Local models, LLM tracing, Speech pipeline

Solutionist — AI-Powered Case Management

Problem: Case investigation resets every time. No memory of what worked before, no way to build on past findings. Every new case starts from scratch.

Approach:

• Drop a screenshot. Vision AI reads it, extracts the case context, and the investigation protocol begins — case history, similar patterns, and KB articles surface automatically.
• Past root causes find you. When a familiar symptom appears in a new case, the system already knows what it was last time.
• 5,196 pages of vendor product documentation, auto-crawled and searchable right next to cases and KB articles.
• Fifteen domain-scoped investigation playbooks, distilled from 224 real error signatures, route each new case through a classifier to proven troubleshooting patterns.
• Every finding promotes to the knowledge base automatically, so the system learns from every case.
• Investigation findings that once took hours now surface in minutes — because the knowledge was already there.

Impact: Case investigation that compounds. The more cases resolved, the smarter the next investigation gets.

Stack: React, TypeScript, FastAPI, PostgreSQL, pgvector, Local models, BM25, parent-child RAG

Agentic Skills Framework — Encoded Expertise. Repeatable Outcomes.

Problem: AI without encoded procedures is inconsistent. Every session it asks clarifying questions, skips steps, and reinvents what was already figured out.

Approach:

• A single command runs a 10-step investigation: reads the case, checks KB articles, traces code paths, writes the troubleshooting document, and promotes findings — without being asked.
• The agent knows when to merge branches, rebuild containers, and verify production health. It makes the right call autonomously.
• Skill files are encoded domain expertise versioned in git. The investigation methodology, deployment workflow, documentation protocol — all formalized, all repeatable.
• Every session ends with findings stored, knowledge updated, and the next session starting smarter.

Impact: What previously required dozens of exchanges now runs end-to-end from a single command. The agent doesn't just assist — it executes.

Stack: Agentic coding tools, FastMCP, Python, Bash, Self-hosted CI/CD

Command Center — The control plane — a commander session and one agent per host, working from one board

Problem: Once several AI coding sessions work at the same time, on different machines and different tasks, coordinating them becomes a job of its own. Work gets handed around in chat, a terminal closes with the laptop, nobody can see what each agent is doing or waiting on, and nothing stops a half-checked change from shipping.

Approach:

• A commander session is the one I talk to, by text or from the dashboard. It plans the work and files it on one board, each item with a severity, a batch and exit criteria.
• Each main host runs one agent, which claims a batch from the board, most severe first, and works it server-side, so it survives a closed tab or a dropped connection; any session opens in a browser terminal from anywhere. A different agent's check moves an item to Complete.
• Verify, then deploy: a result is checked — unit tests, browser end-to-end scripts, and a separate reviewer where the stakes call for it — before a gated deploy that hands live connections to the new process, so nothing drops.
• Approval gates, some enforced in code and some by process: a purchase stops at a plan card that only I can approve; other outward messages follow tiered-autonomy rules — routine follow-ups go out, money, legal and escalation wait for me. Anything that needs me lands in one notification bell.
• One view across machines: a session tree shows every session, where it runs, its current job and its resource use.
• Shared tools under the same control: one real browser that agents drive, with a panel showing which agent holds which tab; and remote help — a session on another PC, started from the same dashboard.

Impact: Nexus holds what the agents know and Solutionist holds the work; Command Center decides who does what, where, and when it is safe to ship. Several agents work in parallel without the whole picture living in my head. It is the newest component — first commit 25 September 2026.

Live: a Projects page, and a work board with lanes from severity backlogs through QA to Complete.

Stack: Python, aiohttp, WebSockets, xterm.js, tmux, Playwright, pytest, OIDC single sign-on

Command Center, in use

Measured 2026-09-27: 566 automated tests (565 pass, 1 skipped); 26 browser end-to-end scripts in the deploy gate; 7 live sessions across 3 machines; 393 work items marked done in the last 7 days; 246 commits since the first, two days earlier

• Command Center dashboard: a session tree grouped by machine on the left, and details for the selected session on the right — its task, queue, helpers and resource use. The dashboard, showing this very portfolio update as a queued task.
• The notification bell opened, reading 'Nothing needs you', with a collapsed list of paused items. The notification bell: anything that needs a person lands here.
• The same session tree on a phone-width screen. The same view on a phone.

Infrastructure

Self-hosted infrastructure designed around the CIA triad — confidentiality, integrity, and availability. Purpose-built AI workstation with 128 GB unified memory and 96 GB iGPU VRAM for local model inference. A hypervisor runs the framework host and its service VMs, and three redundant DNS resolvers serve every service under a name, so a host migration is a one-line DNS change.

• FQDN-routed service mesh — every internal service resolves through a name on the DNS resolvers. Moving the speech service from one host to another took editing a single DNS line; no consumer code changed.
• Layered backup strategy: hourly database dumps, daily VM images, and nightly offsite replication to NAS — complete enough to rebuild from cold, with a ≤1-hour loss window for application data.
• Master disaster-recovery plan: printable runbooks for every host and service, from single-VM restore to a full cold-start sequence — with per-service RTO/RPO and a maintained known-gaps register. A copy lives on the backup NAS so it's readable when the primary host is down.
• Self-hosted Git and CI/CD with protected branches, merge requests, and container registry; tests must pass before any production deploy. No external dependencies in the development pipeline.
• Observability built in — every agent session is tracked and auto-summarized, and a recurring benchmark suite re-scores local models so task routing stays current; per-call LLM tracing is instrumented. Per-agent activity feeds publish over SSE for real-time UI sync across surfaces.
• Security hardened: default-deny inbound at the network edge, SSH key-only authentication, secrets encrypted in the repository (git holds ciphertext only) and kept out of every agent's context by a guard that knows their values, a CDN proxy for external access, and cron-driven watchdogs that alert by text message.

The system, in numbers

Live figures from the running system, measured 8 October 2026 — the context every agent draws on.

• 20,367 Memories — episodic, semantic & procedural — one deduplicated pool
• 19,737 Knowledge chunks — 1,828 consolidated entries, small-to-big retrieval
• 1,136 KB articles — distilled fixes, written by the agents
• 2,421 Agent sessions — logged and learned from
• 5,196 Docs indexed — product docs, auto-crawled
• 741 Work cases investigated — each one leaves the next smarter
• 661 Work KB articles — one index — 506 the vendor's, 155 written here
• 4 Surfaces — messaging · web · voice · terminal — one brain

How it works

Just talk — it already knows

• I bring up something we worked through weeks ago — no setup, no re-explaining.
• The agent recalls the decision, the reasoning, and who was involved.
• It picks up where we left off — whether I'm texting, on the web, or talking out loud.

Share a case — it investigates

• I hand it a support case; it reads the context on its own.
• It pulls the related KB articles and past cases with similar symptoms.
• It runs the investigation and surfaces the likely root cause — in minutes.
• It runs only on local models; the one cloud model in the loop is my work assistant, which asks it the questions.

Guardrails

Agents are powerful and fallible — the framework assumes both. Autonomy where it's safe, hard stops where it isn't.

• Tests gate every deploy — Merging to main runs the full test suite plus security scans; the deploy stage only fires if everything passes. There is no manual bypass path to production.
• No model names in code — Everything references semantic task aliases. Swapping a model is a one-line registry change — a rule written after hardcoded model tags broke three features in one quarter.
• Memory cleans itself — A nightly consolidation pass prunes low-value memories, merges near-duplicates, and uses an LLM to catch contradictions — the older fact is marked superseded, audit trail preserved.
• Destructive ops require a human — Restore and database-reset scripts refuse to run non-interactively. Added after an agent helpfully “tested” a restore against production. Once.
• Outbound autonomy is tiered — Routine follow-ups on a matter I already started go out on their own, through one guarded path that refuses any other recipient or sender. Money, legal or regulatory filings, and any change of tone wait for my approval of that specific message. Every send is logged and filed, and one switch holds all outbound contact.
• Every session is scored — Agent sessions end with automatic verification and a compliance score, and the learnings are extracted into memory — capture doesn't depend on the agent remembering to save.
• Least privilege for outside agents — An agent outside the trust boundary gets a purpose-built gateway, not the real API: allow-listed tools, one sanitized knowledge domain, one memory pool — enforced server-side, so a confused (or compromised) agent can't ask its way past the scope.
• Cross-boundary writes leave receipts — Everything an outside agent files arrives through one schema-enforced contract, stamped with its source, and drops a receipt into an audited trail — with a ping to my phone the moment it lands. No silent writes.
• It watches itself — and heals — A five-minute loop probes containers, endpoints, DNS, hosts, and backup freshness. Mechanical faults get a bounded auto-restart — data stores are never auto-bounced — and everything else escalates to an agent with the evidence attached. My phone gets the arc: found, progress, resolved, or needs-me.
• Delegated answers carry receipts — When one agent hands work to another, every claim comes back marked counted (command shown), read (file and lines named), or inferred — and a verification gate re-derives the original questions before anything resolves. Added after a delegated analysis shipped four confident wrong claims. Once.
• The framework maintains itself — Improvement runs on a calendar, not on memory: a weekly loop that ranks the framework's own recurring failures and pilots fixes, a weekly watch on the AI platform it's built on, a monthly retrospective that refines the agents' own skills, a recurring local-model benchmark, and a monthly currency pass over the disaster-recovery book. Stagnation is treated as a defect.
• Cheaper isn't adopted on faith — Before a cheaper model takes over a recurring job, both run the same real tasks and the outputs are judged blind against ground truth. The first such test kept the scheduled reports on the stronger model: the cheaper one lost all four.
• Every helper names its model — A helper agent dispatched without an explicit model is refused outright — added after unpinned helpers silently ran on a smaller model than intended and one invented a detail.
• Adversarial review before it ships — Public pages and framework changes go through multi-agent review — separate reviewers for privacy, accuracy, and voice, their findings verified against the running system before anything deploys. This page went through three of them.

Where It Runs

The machines behind the framework and what each one does. Hypervisor: physical server, hosts the virtual machines.

• Primary host (VM on the hypervisor) — Runs the framework; Command Center — the control plane: the commander session, the work board, the approval gates; Nexus memory and the knowledge base; The model router; The text-message line in, and notifications out; The shared browser agents drive
• DNS resolver 1 (VM on the hypervisor) — Name resolution
• Isolated VMs (VM on the hypervisor) — Kept apart on purpose — one runs a public-facing agent that holds no personal data
• Model host — physical, 128 GB unified memory; Local models and warm standby; Local models, served on the machine; Its own agent, working batches from the board; A standby copy of the framework, kept current; A second assistant on local models that keeps working offline; DNS resolver 3
• Light hosts — laptops and a spare PC; Extra job capacity; Small jobs placed by the framework, capped on CPU and memory; A gaming laptop pauses our work while a game or VR session runs
• Backup NAS — physical, separate from the hypervisor; Backups; Nightly VM images and database dumps; A copy of the restore runbooks
• DNS resolver 2 — small ARM board; Name resolution; Three resolvers on three different machines, so names still resolve if the hypervisor is down

How work flows:

• Ask — A request arrives by text message or from the Command Center dashboard.
• Commander — The commander session plans it and files items on the work board.
• Agents — Each host's agent claims a batch; another agent's check moves it to Complete.
• Verify — Tests, browser checks and a separate reviewer — before anything is trusted.
• Deploy — A gated deploy that keeps open connections alive.
• Report — One message back: what changed, and anything that needs a decision.

Build timeline

• Oct 2026 — Assistants can reach only approved recipients The messaging assistants' outbound paths are locked below the agent: messages and mail leave only through relays that check an allowlist of recipients, the assistants hold no mailbox password, and the local-model assistant runs under its own restricted account.
• Oct 2026 — Secrets are stored in git only as ciphertext Every credential file in the repository is now committed encrypted, never in plain text. Each host that needs them decrypts with its own key, so adding or removing a machine is a change to the recipient list, and a helper commits a secret edit in its encrypted form.
• Oct 2026 — A dedicated firewall at the edge A dedicated firewall replaced the all-in-one router as the gateway; the old router now only provides wireless and switching. Its configuration is backed up off the box nightly. A queue-management shaper cut added upload latency under load from 33 ms to 4 ms, and its logs feed the central log server, where an agent watches for alerts.
• Oct 2026 — One registry for every schedule More than 120 recurring jobs spread across both hosts moved into one registry that survives reboots. A guard refuses ad-hoc timers and direct crontab edits, and one command lists every schedule on every machine.
• Oct 2026 — One work board — and a worker never closes its own item Every follow-up, backlog idea and open loop from every agent lives on one board; the older side lists were migrated onto it and retired. Each item carries a severity, a batch and exit criteria. An agent claims one batch at a time, most severe first, and marks it done with evidence; only a separate check — a test or a live probe — moves it to Complete.
• Oct 2026 — One agent per host, and a commander that plans but doesn't build Replaced the lead-plus-workers model. Each main host now runs one named agent, and topic work becomes that agent's projects rather than another session. A commander session plans the work, assigns it and checks results, and does not write code by default.
• Oct 2026 — Calls: it answers and joins, and never dials anyone on its own A voice assistant is built to answer and join calls on my behalf, and it introduces itself as my AI assistant. It never places a call by itself: today the only call it dials is an emergency call to me, and a call it places at my request will connect me in to do the talking. Federal rules count an AI-generated voice as an artificial voice that can't call someone who hasn't agreed to it, and Washington needs everyone's consent to record, so calls with other people are not recorded. The planned Agents panel was replaced by the work board.
• Sep 2026 — Support packages parsed by code, not read by a model Event logs, service logs, registry exports, scan artifacts and the product's local database are parsed deterministically and merged into one cross-file event timeline. A delegation worker answers routine requests straight from those parsers.
• Sep 2026 — Per-caller keys on the memory service Each agent and app now calls the memory service with its own key. Every call is logged against its caller and rate-limited, so one misbehaving client can be identified and cut off without touching the others.
• Sep 2026 — Work data stays on local models The support platform is locked to local model roles in code: a cloud model in its settings is refused or swapped for a local role, and anything the local pass cannot settle goes back to the requester. Case-derived writes into the shared memory were removed, because other agents read that pool by default.
• Sep 2026 — An incident bridge — one room, one commander When the health loop opens an incident about a host, every agent working there is called into a shared room and checks in with one line. The most capable agent that didn't cause the fault becomes commander, and after that only the commander and I talk. The room is replicated across both hosts. If no one answers, I am paged, and a top-severity incident phones me.
• Sep 2026 — Projects page in Command Center A Projects page, live since 27 September, that groups work by project.
• Sep 2026 — Machine enrolment — a new worker joins with one script A new machine enrols itself with a checksum-pinned script and a one-time token, then locks down its own remote access. The first production enrolment finished on 27 September; more machines followed in early October.
• Sep 2026 — Remote help from the dashboard A remote session on another PC, started from the same Command Center dashboard.
• Sep 2026 — Secret values can't reach the model A guard now matches the actual secret values rather than the shape of a command: it blocks a command or file write that carries one, redacts one from tool output, and bounces a helper's answer that contains one. Each path was proven by planting a decoy; an hourly watchdog re-registers the guards if any go missing.
• Sep 2026 — Blind side-by-side before choosing a cheaper model Tested whether a cheaper model could take over four recurring reports: the same real tasks, run on both, judged blind against ground truth. The cheaper model skipped required steps and lost all four, so the reports stayed on the stronger one.
• Sep 2026 — My text line now goes to the Lead Texts I send reach the Command Center's lead session directly, and it answers from the same number. The earlier assistant persona no longer handles the conversation; it still sends scheduled notifications and reminders.
• Sep 2026 — Command Center — one place to run and watch many AI coding sessions Sessions run on the server and survive a closed tab; a session tree spans every machine, a shared queue carries the work, and a bell collects anything that needs a person. First commit 25 September. A day later it absorbed the older apps hub, which was retired.
• Sep 2026 — A weekly improvement loop that starts from our own failures The improvement scan went from monthly to weekly and from trend-first to pain-first: it ranks the framework's own recurring failures from evidence, looks for fixes in the wider field, verifies them in source, pilots them, and reverts anything that doesn't move its metric.
• Sep 2026 — Governed delegation — agents act on my behalf, within tiers Outbound contact moved from draft-only to tiered autonomy. Routine follow-through on a matter I already started goes out through one guarded path that refuses any other recipient or sender; money, legal filings and escalation still wait for my approval of the specific message. Every send is logged and filed, written channels stay the default, and a single hold switch stops all outbound contact.
• Sep 2026 — Decisions arrive as a text; tickets never wait on me Tickets are for agents to task each other. Anything that needs me now comes as one text with the question and a recommendation — and if I don't answer, the recommendation stands unless the choice is irreversible or outward-facing.
• Sep 2026 — A shared browser that every agent drives One real browser with a persistent profile, which agents drive and I can watch live. Each task opens its own tab and closes it when done, so sites that turn away automated fetches can still be read.
• Sep 2026 — Context treated as the budget — measured, then cut Measured where the spend actually goes: about 96% was sessions re-reading their own context on every step, not the model's own work. Bulk reading moved into helper agents that return only conclusions, and a gate now refuses any helper dispatched without an explicit model.
• Sep 2026 — Audited the backups and found the offsite layer had not existed for hours — with every check green The offsite copy lived on a NAS whose storage pools silently failed to import after a reboot. With the pools gone, the mount point was just an empty directory on the NAS's small boot disk — so the nightly job recreated the tree there, copied into it, counted 453 files and logged success. The health check then read a timestamp out of that same decoy and called the offsite copy fresh. And when it did finally catch something — an hourly snapshot 262 hours stale on the second host — its alert was posting to the wrong API shape for the messaging daemon it was calling, and the 404 was being swallowed by a silent curl flag. Three layers of green over nothing. Fixed all three: both backup jobs now prove the destination is its own mount before they write, the health check verifies the storage it measures and that the notifier itself is alive, and an unmapped host is now a hard error rather than a quiet guess. The recovery plan was corrected to match, including a warning that a green health log is not proof of coverage.
• Aug 2026 — Autonomous incident response across both hosts A five-minute loop probes containers, endpoints, DNS, hosts, mounts and backup freshness. A confirmed fault gets a bounded restart of named app containers only — data stores are never auto-bounced — and anything harder becomes a ticket with the evidence attached, worked by a resident agent while my phone gets found, progress, resolved.
• Aug 2026 — Assigned dissent and a decision register High-stakes verdicts — irreversible, costly, legal, medical or financial — now get an adversary first: a separate agent that sees the evidence and the conclusion but not the reasoning. Each decision is then recorded with what would prove it wrong and a date to check, and the register refuses an entry without both. From then on, only those recorded decisions feed the behavioral user model.
• Aug 2026 — Scheduled self-improvement — the framework maintains itself on a calendar Recurring agent sessions started running on a fixed cadence: a weekly watch on the AI platform the framework is built on, and monthly retrospectives that refine the agents' own skills. Each run ends verified and scored like any other session.
• Aug 2026 — Agent ticketing — work handed between agents as tracked items Replaced ad-hoc hand-offs with a ticket system: an agent files a request, a resident agent claims it, posts progress, and resolves it with the answer. The full request → work → resolution history is kept and reviewable.
• Aug 2026 — Disaster-recovery book — printable restore runbooks for every service, verified against the live systems Wrote the full disaster-recovery plan for the infrastructure: 15 chapters covering network, DNS, hypervisor, NAS, both framework hosts, Windows VMs, and external services — a what-died decision tree, a cold-start sequence, per-service restore procedures with RTO/RPO, and a known-gaps register. An independent verification pass fact-checked ~500 claims (paths, container names, backup artifacts) against the running systems and corrected 79 before the book shipped. The audit also caught two problems: a backup job that had been paused while its app quietly came back to life, and hypervisor network-recovery scripts that existed only on the hypervisor they were meant to recover.
• Aug 2026 — Framework audit — retired a third of the tool surface, and added an answer engine that works offline Went through the memory service looking for what to delete rather than what to add: scheduling, calendars and reminders came out entirely, because another component already owned them. The tool surface went from 177 to 119 and the dashboard lost four tiles that had been reporting on nothing. What went in was smaller and more useful — a grounded question-and-answer path that retrieves across memory, knowledge, articles, projects and sessions in parallel, cites its sources, and falls back to a model on the local box so it still answers with the GPU host or the internet down.
• Aug 2026 — Caught a duplicate-write defect — 63% of the memory pool was byte-identical copies A live session appends to its transcript continuously, and the ingester re-read any file whose modified time had moved — so every scan re-stored the same memories, roughly 96 copies per working day. Nothing at the write path caught it, because the documented auto-dedup only runs in a mode the local models are too slow for. Fixed both layers: a quiet-period gate so a transcript is only ingested once its session is over, and a hash check at the write path. Then removed 29,713 duplicate rows, full backup taken first. The pool is a quarter of the size it was and every agent's search got cleaner for it.
• Jul 2026 — An offline assistant on local models, permanently The standby assistant runs on local models for good, so it is exercised every day and still answers with the internet or the primary host down.
• Jul 2026 — Least-privilege agent access — a second assistant connects through a scoped MCP gateway A second assistant, operating outside the trust boundary, now connects to the framework through a purpose-built MCP gateway that enforces its scope server-side: one domain of sanitized, self-authored findings, one memory pool, writes only through a create-only capture tool — and even a direct article id can't reach beyond the scope. The same least-privilege discipline behind enterprise PAM, applied to my own agents, plus a message queue so the two assistants coordinate across the boundary, each incoming request pinged to my phone.
• Jul 2026 — Domain playbooks — 15 investigation playbooks distilled from 224 real error signatures Distilled 224 real error signatures into 15 domain-scoped investigation playbooks; a classifier routes each new case to the right one, so investigations follow proven paths.
• Jul 2026 — Work-knowledge bridge — structured captures from outside the trust boundary flow into the shared brain A pipeline that carries sanitized, structured findings across the trust boundary into the shared knowledge base — the framework learns from cases it never directly touched.
• Jun 2026 — Two-host production — active host plus a warm standby, kept current on every merge Moved to an active host plus a warm standby, kept in sync on every merge through CI. A host failure becomes a one-line DNS change instead of an outage.
• Jun 2026 — Honcho dual-memory — a behavioral user-model alongside factual recall Split 'what's true' (facts in Nexus) from 'how I work' (a behavioral user-model in Honcho) — two memory layers, so preference and personality don't get confused with fact.
• May 2026 — Self-healing memory consolidation Memory that maintains itself — a nightly pass prunes low-value entries, merges near-duplicates, and flags contradictions.
• Mar 2026 — A model gateway — code asks for a role, never a model Every model call now goes through a self-hosted gateway using semantic task aliases such as default, vision or reasoning. Swapping the model behind a role became a one-line registry change, a rule written after hard-coded model names broke three features in one quarter.
• Mar 2026 — Nexus 2.0 — consolidation, matured hybrid search, pgvector throughout A consolidation release: nightly dedup and merge of memories, a matured hybrid search, and pgvector standardized across every store.
• Feb 2026 — Hybrid BM25 + vector retrieval and entity extraction Combined keyword search (BM25) with semantic vector search so a query matches both exact terms and meaning, plus entity extraction to pull structured facts out of freeform notes.
• Feb 2026 — A real memory layer, and a temporal knowledge graph that was later retired Added a proper memory layer over pgvector and a temporal knowledge graph to track how facts connect and change. The graph's extraction stopped later that month; retrieval kept working without it, and a measurement in August confirmed it had not been written since.
• Jan 2026 — Multi-surface access — the same brain reachable from a messaging app, the web, and voice The same agent started answering in a messaging app, in a web chat, and out loud — all calling the same Nexus API. Move from texting to typing to talking mid-conversation and nothing resets.
• Jan 2026 — Nexus born — FastMCP server with persistent, cross-session agent memory Pulled the memory out of that single app and made it a service any agent can call over the Model Context Protocol. The shift from a feature to shared infrastructure — one brain instead of one brain per app.
• Dec 2025 — Solutionist begins — hybrid-RAG case management on FastAPI + pgvector The first piece: a support tool that reads a case screenshot, extracts the details, and pulls up similar past cases and KB articles on its own. It proved the core idea — retrieval beats re-explaining — and everything else grew out of it.

Stack

Runtime

Python, FastAPI, FastMCP, React + TypeScript

Data & memory

PostgreSQL, pgvector, Redis, A shared memory service, A user-model service

Models

Local models first, A frontier model for reasoning, A model gateway with task aliases, Local embeddings

Ops

Docker Compose, Self-hosted CI/CD, LLM tracing, Loki + Grafana, A KVM hypervisor, Edge hosting + serverless functions