How the Corvair Knowledge Substrate runs.

One governed API in front of four services, over one index database and a private object store. Work someone waits for runs live. The rest runs in batch.

The services behind one API

Every caller goes through one governed API. It resolves the tenant and identity, applies the caller's scopes, and shows a preview before any change. Behind it, four services share one index database and a private object store. Work nobody is waiting for runs in the background, in batch.

Corvair Virtual WorkerYour applicationscks command lineGoverned API and MCP toolstenant and identity, scopes, a preview before any changeKnowledgesearch, claims, sitesMemoryconversations,learningsVaultfiles, scans, versionsWarrantsseals, ledgers, checksIndex database and private object storeone database; each document's OKF record kept as filesBackground work: batch writing at half price, quick judgements, scheduled crawls and link runs

The API is the only way in. MCP tools forward to the same routes. So access rules and previews apply once, for every interface.

Knowledge

Knowledge holds what an organisation takes as true: sourced, tiered and checked. It serves search, answers, crawled sites, topic maps and heat maps.

  • The record. The Knowledge Substrate writes one Open Knowledge Format (OKF) record per document as the document is read. Each load is a new version. Nothing is edited in place.
  • The search tables. Passages, topics, terms, tags and claims sit in the index database. They are built from the records with no model call, so they can be rebuilt from the records at any time.
  • Claim links. Which claims support, depend on or contradict each other. A scheduled link run finds them. They are kept beside the records, not in them.
  • Sources. Your own content, outside sites crawled on a schedule, and generated drafts. Each passage keeps its source and its tier.

Memory

Memory keeps the record of the work: events, decisions, memories and learnings. It assembles the context a person or agent needs to carry on. Every change to a project is an event, and events are never rewritten. Everything else Memory stores can be dropped and rebuilt from the record. It all lives in one index database schema.

ComponentWhat it doesRuns
Governed APIAuthenticates the caller, resolves tenant and project, keeps knowledge-base-scoped agent credentials inside their scenario, enforces idempotent writes and preview tokens.On each request
Service interfaceOne typed contract for every operation, so routes never reach storage directly.On each request
Event recordAppends events, assigns their order, and derives conversation state, rounds, the project digest and links.On each request, plus steps after commit
ContextAssembles prompt context within a budget the caller states, filters it by who is taking part, and serves prepared summaries.On each request
PreparationSummarises one span of older events per run, extracts structure, and processes export jobs.Background worker
MemoriesLong-term user and project memories: create, generate, consolidate, search.On each request; generating calls a model
GovernanceRedaction, legal holds, erasure with sealed receipts, and exports.On each request and in the worker
Activity relayPublishes each committed event to subscribers and on to connected clients.After commit

Vault

Vault holds files: uploads and the files agents generate. Bytes live in a private object store. Rows (files, versions, upload sessions) live in the index database. Every upload path lands in one session service, one state machine and one scan path.

PartWhat it does
Upload sessionsTake chunks, check size and checksum, and seal a version. An interrupted upload resumes.
ScanChecks file structure and active content, and runs a malware scanner beside the API. A file is held only for malware, active content or file type. Personal data is found and flagged, and the application decides.
OrganiseKeeps system folders. A manual placement wins over an automatic one.
ServeGives short-lived grants for reads, with range reads and previews. Every read checks the version and its hold again.
AdmitSends a clean file to the Knowledge ingestion gate. The gate calls back with a verdict, and the file becomes ready or failed.
Derivative serviceA separate service that makes thumbnails and previews. Two task queues, fast and batch, feed it.
Purge jobRemoves expired uploads.

Warrants

Warrants seal decisions, and answers when asked. The API builds and stores each warrant. A private service holds the key. Warrants, chains and ledgers are kept in the index database.

PartWhat it doesRuns as
Issuing pipelineBuilds the payload, puts it in one exact form, locks the head of the chain, asks for a signature, and saves every durable effect in one database transaction.Part of the API
Signing serviceSigns the bytes it is given and obtains the timestamp. It is the only identity allowed to use the governance key. Callers prove who they are with short-lived identity tokens.Private service
Timestamp serviceIssues RFC 3161 timestamps. Its key is kept apart from the governance key, and its certificate chain is published.Separate service
VerifierRuns the seven checks online through the API, or offline from an exported bundle with no database.API, and a standalone command
Chain sweepRe-checks every chain from end to end and stops at the first broken link.Job, on demand
Erasure seal retrySeals erasure receipts whose warrant failed at the time, without erasing again.Job, every 15 minutes

Shared foundations

  • One database. The index database holds the search tables, the Memory record, Vault rows and the warrant chains.
  • Private object store. It holds the bytes of Vault files. It is not open to the public.
  • OKF records as files. Each document's OKF record is kept as files. It is the record of truth. The search tables can be rebuilt from it with no model call.
  • One boundary per service. Services reach one another through typed calls, queues and events, never through each other's tables.

Live and batch work

The Knowledge Substrate splits work by who is waiting. A document is searchable in seconds with no model call. A question is answered live. The rest is written later, in batch, at half the price. Quick judgements check claims as batch results land, and judge pairs of claims in the scheduled link run.

Ingestion, live. A document is searchable in seconds. No model call.Collectscan andhashParsetext andOCRChunkpassagesIndexkeyword searchin the indexdatabaseBundlethe OKFrecordGaterules, perdocumentEach question, live. Someone is waiting.Rewritea modelRecallkeywords,aliases, nearspellingsFuserank thematchestogetherReranka quickjudgementGeneratea modelCiteclaims,passages,tiersOn a schedule, in batch. Nobody is waiting.Describe, tagbatch writing,one perdocumentClaimswhen the baseis set to fullCheck claimsquick judgement,own passageFind pairscode only,no modelJudge pairsquickjudgementFlagcontradictionson the answersthat use them

Two speeds of ingestion

  • Live. Collect, parse, chunk, index, write the OKF record, gate by rules. No model call.
  • Batch. Describe and tag each document, and extract every claim where the base is set to full. A batch job can take up to a day.
  • Quick judgements. Claim checks run as each batch result lands. Pair judging runs in the link run.
  • Setting. A base setting decides whether a document a person adds is described live or in the next batch. Bulk work, such as a re-ingest or an import, always goes to batch.

What runs in batch

WorkWhen it runs
Describe and tag, for re-ingest, imports and crawlsNext batch
Full claim extractionNext batch
Dated change summaries for crawled competitor and industry sitesNext batch, one call per site
Generated articlesNext batch
Topic summaries for Memory, and learnings across many conversationsScheduled run
Gap and inconsistency reviewScheduled run
Sealing a warrant, and preparing Memory contextIn the background, after the request is accepted

Connect your first assistant.