Cannon
A personal multi-agent assistant where each domain gets a dedicated specialist — its own persona, its own system prompt, its own tools and its own retrieval scope — instead of one generalist chatbot wearing hats. Four desks ship with it. The rest you type into existence.
Case study: harshith-nayaka-l-portfolio.vercel.app/work/cannon: the problem, the architecture and the engineering decisions behind Cannon.
Built to be used daily, not demoed once. The fitness desk holds real training data, the work desk a real task board, the finance desk real spend, the learning desk a real reading queue. The portfolio artifact is a by-product of a tool that had to exist anyway.
Cannon is domain specialisation, not task orchestration. Its sibling project, Maestro, splits a single task across collaborating roles (Thinker / Worker / Verifier / Synthesiser). Cannon runs independent experts that share infrastructure and deliberately do not share context. Different architecture, different problem.
What is actually interesting here
1. Agent isolation is enforced at the query, not by convention.
The fitness agent cannot read work documents even by accident. Retrieval takes the agent id as an argument and the Postgres function filters on it internally — there is no post-filter a caller can forget. In the memory store the same boundary is a WHERE on the scan, and both paths are unit-tested with mirror-image queries.
2. Provider fallback is a model, not a try/catch.
createFallbackModel implements the AI SDK's provider interface and wraps Groq → Gemini. streamText, tool execution and the UI stream protocol are all unaware a swap happened. It covers two distinct failure modes: the call that never connects, and the call that connects then errors before emitting content. Once real content is flowing, a mid-stream failure is surfaced rather than silently restarted — re-running a partially executed tool chain is worse than a visible error.
3. Every external dependency has a working fallback.
No provider key, no database? The app still boots, builds, passes its whole test suite and serves a fully working demo. Inference falls back to a scripted model that implements the real provider interface, embeddings fall back to a deterministic lexical embedder, storage falls back to a process-local store. This is why CI can run end-to-end tests with zero secrets — the tests exercise the production code path, not a mocked-out shortcut.
4. The roster is open — you type a domain and get an agent for it.
Describe something no desk covers and Cannon writes one: the model produces the persona, the system prompt, the routing vocabulary and the starter prompts; the server decides the slug, the accent and the uniqueness, because those become a URL and a primary key and "trust the model to emit a valid slug" is not validation. The new desk is real, not a skin — it gets its own row, its own accent, its own retrieval namespace, and two tools (remember, recall) that write to the database and embed into a scope only it can read. It appears in the rail, joins the routing vocabulary, and can be deleted, which takes its records, embeddings and transcript with it. With no provider key the persona comes from a deterministic generator instead: worse prose, same working agent.
5. Dispatch is a recommendation, not a router.
The front door takes the request in plain words, scores it against every desk's own vocabulary, and picks a model for the shape of the request — widest context for a wall of pasted text, strongest reasoner for a judgement call, fastest for a short capture. Both choices are shown with their reasons and both can be overruled before anything runs. Deliberately a deterministic scorer rather than an LLM classifier: routing sits in front of every request, so a model round-trip there taxes all of them, and a wrong guess sends work to an agent whose tools cannot serve it. It is instant, free, explainable in the UI and unit-tested.
6. The Inspector.
A docked panel showing the tool signatures in scope, which provider actually answered, whether a fallback fired, and the exact chunks retrieval pulled with their similarity scores. The system prompt is deliberately not in it — toProfile strips it at the server/client boundary, and an e2e test asserts it never appears in the page or the RSC payload.
7. The model list is live, not hard-coded.
Providers do not hold still — Groq retired Kimi K2 and Qwen3 32B and shipped Qwen3.8 27B within a few months. So the picker asks each provider's own /models endpoint what this key can call right now (cached for an hour), and the catalog is demoted to annotations. A model we know keeps its published speed and a one-line note on what it is for; a model the provider lists that we have never seen still appears, marked New; one the provider has stopped listing disappears instead of 404ing on the next turn. Preview models are labelled as such. If the configured default is ever retired upstream, the chain quietly moves to the first model the provider still lists. If a listing cannot be fetched, the built-in catalog stands in for that provider alone. GET /api/health reports which lists are live and which models are new.
8. Tool results are data, not pasted JSON.
Every tool returns a tagged, typed result that the chat surface renders as a real card: an RPE meter and a next-load recommendation for a logged set, a volume sparkline and a trend verdict for a progress query, a filterable board with a slipping banner, a category breakdown with budget usage, a reading queue that flags what has gone stale.
This is the beginning of the README. Read the rest at the original. Read the full README ↗
