Kigo

In production Try Epos →

Kigo is the retrieval system behind Epos on chathaiku.com. It gives a 1.5B-parameter model access to a small, hand-curated knowledge base — and, just as importantly, decides when not to use it. This card describes what it retrieves from, how it decides, and what it does with your questions.

Overview

A small language model has a small memory. Epos knows a great deal about language and very little about last Tuesday, and — like every model its size — it fills gaps confidently rather than admitting them. Retrieval-augmented generation is the standard answer: search a document collection, put the best matches in front of the model, and let it read rather than recall.

In a haiku, the kigo is the seasonal word — a single term that points outside the poem to a whole shared body of knowledge the reader already has. That is the job here. Kigo is a local knowledge base that runs on Rootcomputer's own hardware alongside the model. There is no third-party search API, no external vector service, and no per-user document store. The whole index is a directory of plain-text files, a matrix of embeddings, and roughly two hundred lines of retrieval logic.

Kigo is live for Epos 2.1 at chathaiku.com. Most of the engineering in it is not retrieval — retrieval is one matrix multiply — but restraint: knowing when the knowledge base has nothing useful, and refusing to claim otherwise.

Architecture

Specifications

Documents are chunked, embedded once at build time, and searched with a fused dense + lexical score. No approximate-nearest-neighbour index: at this scale an exact brute-force search is faster than the overhead of maintaining one, and it never returns an approximate answer.

MiniLM
Embedder
(multi-qa-MiniLM-L6-cos-v1)
384
Embedding dimensions
Hybrid
Dense cosine
fused with BM25
Exact
Brute-force search
(no ANN index)
~14 ms
End-to-end retrieval
per query
2
Visibility tiers
(public / internal)
Retrieval latency measured against the live index. Search itself is well under a millisecond; the bulk of the 14 ms is encoding the query. For scale, an Epos reply takes two to six seconds.
How a turn works

From your question to a cited answer

Five stages, in order. Any of the first three can end the turn without retrieval ever happening, and most turns do exactly that.

Flow diagram of the Kigo retrieval pipeline. A user message enters stage 01 intent gate, then flows left to right through 02 hybrid search, 03 relevance gate, 04 injection, and 05 grounding check, ending at an answer with sources shown. Two downward branches exit the main flow: social or thin queries leave at stage 01, and queries below the relevance floor leave at stage 03; both end at Epos answering from its own weights. A third branch leaves stage 05 when the reply is not grounded, ending at the source panel being withheld.
The two early exits are the load-bearing part. A turn reaches injection only if it survives both gates.
01
Intent gate
Greetings, social turns, and questions too thin to search are filtered out before anything is embedded. "Hello Haiku" never touches the knowledge base; "hey, how do I extract a tar file" does — the gate reads what follows the greeting, not the greeting.
02
Hybrid search
The question is embedded and scored against every chunk in the tier you have access to. A BM25 keyword score runs alongside it, because exact identifiers — file names, config keys, command flags — land near noise in a 384-dimensional sentence embedding, and those are precisely the queries where a document helps most.
03
Relevance gate
A match is not the same as a good match. The top hit must clear a calibrated floor on the dense score, or clear a separate keyword path for exact-term queries. Short queries face a higher bar, because with a few hundred candidate chunks something scores respectably against almost any three words by chance. Below the floor, no context is injected and Epos answers from its own weights.
04
Injection
Surviving chunks are placed in the prompt with their source titles attached, inside a fixed context budget measured with the model's real tokenizer. The conversation you sent is not modified — the augmented prompt is a copy, and what you see in your history is what you actually wrote.
05
Grounding check
After generation, the reply is compared against the injected text. If the answer shows no sign of having used the documents, the source panel is withheld rather than shown. Claiming sources an answer did not use is worse than claiming none: the disclosure is your reason to trust the citation, and spending it on an ungrounded reply devalues every honest one.
Disclosure

You can always see when retrieval fired

Every Epos reply that used the knowledge base carries a collapsible source panel, in the same place and the same shape as the existing reasoning disclosure. It names the documents by title, not by file path, and links out where the document came from a public URL. If the panel is not there, retrieval did not happen — either the gate declined, or the grounding check found the answer did not use what it retrieved.

▸ Consulted 2 sources
Rootcomputer model family
ROOTCOMPUTER
Haiku H2 model card
ROOTCOMPUTER
Illustration of the in-product panel. Titles and collection labels are the same ones listed below.
Opt-out
Retrieval fires on a minority of turns by design. Most conversation needs no documents.
Titled
Sources are shown by document title. File paths and directory structure are never exposed.
Withheld
When the reply does not draw on the retrieved text, the panel is suppressed rather than shown.
Sources

What is in the knowledge base

The knowledge base is small and deliberately curated. It is not a web crawl. Every document in it is owned by an entry in a manifest that records where it came from, how often it refreshes, when it expires, and which tier it belongs to; anything on disk without a manifest entry is flagged as an orphan and removed. Curation beats volume here — a few hundred good chunks retrieve better than a few hundred thousand mediocre ones, and an unbounded index dilutes the relevance gate until it fires on everything.

Collection Contents Refresh Public
Rootcomputer Hand-written facts about the lab, the model family, the benchmarks, and the sites. The authoritative answer to "what is Epos" and "what models exist". On edit Yes
Skills Short exact-syntax reference pages for command-line tools where a wrong flag has a loud, immediate failure — git recovery, tar, ffmpeg, curl. On edit Yes
Research Hand-curated notes on small-model training, plus title-and-abstract listings from public arXiv feeds. Daily Yes
Reference topics Scoped pages from public institutional sources on subjects that come up often — for example NASA's climate explainers. Weekly Yes
Current events Headline and standfirst only, from public news RSS feeds. Article bodies are never fetched or stored. Items expire on a time-to-live and are pruned automatically. Every 6 h Yes
Internal Training runbooks, evaluation internals, and operational notes. Used by Rootcomputer's own tooling. On edit No
Collections shift as the knowledge base is curated. The source panel on any given reply is the authoritative record of what that reply actually consulted.

On news feeds specifically. Kigo stores the headline and the publisher's own summary, with attribution and a link, and stops there. It does not fetch article bodies. That restraint is deliberate: a knowledge base full of full-text articles turns a chat model into a redistribution mechanism for work that isn't ours, and the attribution line is what lets Epos say where a claim came from instead of asserting it bare. Feeds carry an expiry, because a document with no expiry lives until someone deletes it — right for organisational facts, wrong for headlines.

Privacy

What happens to your question

Retrieval is a read. Your message is embedded in memory, compared against the index, and discarded — the knowledge base is a fixed corpus built from the manifest, and nothing a user types is written into it.

  • Your conversations never enter the index. There is no learning loop from chat to knowledge base. A document appears in the index only when it is added to the source manifest by hand and the index is rebuilt.
  • There are no per-user documents. Kigo has no upload path and no personal collections. Every user searches the same public index, so there is no mechanism by which one person's content could surface in another person's answer — the class of leak is absent, not merely guarded against.
  • Your question does not leave the machine. Embedding and search run locally on Rootcomputer hardware. No query is sent to a search engine, an embedding API, or a hosted vector database.
  • Retrieval events are logged. Alongside existing inference logs, Kigo records the gate decision, which documents were returned, and the grounding score, so that retrieval quality can be evaluated and regressions caught. These logs are operational, are not shared with third parties, and are not used to train models.
  • No tracking or profiling. Retrieval does not build a per-user history, personalise results, or shape the index around what anyone asks.
Security

Tier isolation

The knowledge base holds internal material — runbooks, evaluation internals — that should never reach a public endpoint. Rather than filter it out at the end, the boundary is drawn at the directory level and enforced before anything is ranked.

  • Visibility is a property of the directory, and it fails closed. Documents under public/ are public; everything else is internal by default. A document with no declared tier is treated as internal, so the failure mode of a misconfigured entry is that it disappears from chathaiku.com rather than that it appears.
  • The filter applies before ranking, not after. A search from a public request never scores internal chunks at all. There is no stage at which internal text is retrieved and then dropped, so there is no stage at which a bug could let it through.
  • The ingest pipeline refuses to cross tiers. A source whose destination path does not sit under its declared tier is rejected at sync time, before the document is ever written to disk.
  • Internal retrieval requires a separate credential. It is reachable only from Rootcomputer's own tooling, and never from the public chat endpoint regardless of what a request asks for.
  • Retrieved text is context, not instruction. Documents are injected as reference material for the model to read. Prompt injection through a retrieved document is a real risk class for any RAG system, which is one more reason the index is a small hand-curated set of trusted sources rather than an open crawl.
Limitations

What Kigo does not fix

Retrieval improves what a model has in front of it. It does not improve the model. Epos is a 1.5B-parameter system and everything true of it without retrieval remains true with it.

  • A retrieved document does not guarantee a correct answer. A small model can be handed the right paragraph and still summarise it wrongly. The grounding check measures whether the reply drew on the context, not whether it read it correctly.
  • Most turns retrieve nothing. That is intended, but it means the absence of a source panel says nothing about whether an answer is reliable — only that it came from the model's own weights.
  • The index is small and Rootcomputer-shaped. It is strongest on the lab's own models, benchmarks and tooling, and on the specific command-line references it covers. It is not a general knowledge store, and it is not a search engine.
  • Current-events coverage is shallow by design. Headlines and summaries, on a refresh cycle. Epos may not know about something that happened this morning, and where it does, it knows the headline rather than the story.
  • Content can be stale within its refresh window. A page that changes without notice is only as current as its last fetch.
  • Not for safety-critical use. Epos with retrieval has not been evaluated for medical, legal, financial, or otherwise consequential applications, and adding a document to a prompt does not change that.
Related

Elsewhere on this site

Status
Live service health, including a knowledge base card reporting index size and how recently it was rebuilt.
Model
The deployed model this system serves. Retrieval is on by default; the source panel appears on replies that used it.