opbox

Knowledge Base

The workspace's living library of pages, know-how, and captured material - written, organised, searched, and curated under one front door.

The knowledge base is where a workspace keeps what it knows. Pages and documents live in a hierarchy you can navigate like a tree, edited in place and versioned as you go. Reusable know-how (guidance, precedents, internal process) is reviewed and published so the assistant and your team draw on the same vetted material. Captured material from elsewhere (uploaded documents, messages, notes, voice transcripts) flows in through one intake, gets indexed, and becomes findable. Everything here is read and written through the same governed verbs as the rest of Opbox, so a page, its history, its sharing, and who is reading it right now are all part of one accountable record.

What it does

A document tree you navigate page by page. Documents are organised as a hierarchy: each one can have a parent, and the children load as you expand a folder. The panel reads the tree from doc.list (the roots are the documents with no parent; expanding a node lists its children), and selecting a page opens it for reading. The listing is metadata only; the content itself is the source of truth and is fetched on a separate, permission-checked read.

Pages you read and edit in place. Open a document and you get its record header over the canonical content body. Create a new page, edit an existing one, and the edits go through the kernel rather than a side door. The reader is driven entirely from the verb’s render schema, so what you see on the page is exactly what the verb returned, with no second copy that could drift.

Version history that is kept, not overwritten. A document carries its versions: editing creates a new version, the old one is retained, and the history is readable rather than lost. Files behind the documents follow the same rule (a superseded file keeps its place in the version chain, with links retained), so you can always see what a page or its attachments looked like before a change.

Comments and annotations on the work. Add notes against a document, including page-geometry annotations on a PDF (a bounding box, an arrow, a comment anchored to a point on the page). Annotations are first-class records you can read back and remove, so review happens on the document itself rather than in a separate thread.

Sharing and per-object visibility. Share a document with another person, and set how visible an object is to those who can reach it. Sharing is an access-control write, audited like any other, so reach into the knowledge base is always something that was granted on the record, never something that quietly widened.

Follows, favourites, and live presence. Mark a page as a favourite or follow it to keep track of it; your own follows and favourites are a durable list you can read back. Presence heartbeats show who is looking at something right now, so when a page matters to more than one person you can see that you are not the only one in it.

Curated, reviewed know-how. Beyond ad-hoc pages, the knowledge area holds reusable know-how (guidance, precedents) as governed entries. An entry can be proposed, then reviewed, then published, and a published entry is superseded (append-only, with a validity window) rather than deleted when it changes. Publishing and curation are gated, so what the assistant treats as authoritative guidance has actually been signed off, and the history of what was authoritative when is preserved.

Unified search across everything. A single search runs over the workspace combining vector (semantic) and lexical retrieval, merged together, over a two-tier index. It is the read workhorse: one query reaches across documents, matters, and parties rather than making you guess which store to look in. Embeddings sit behind it, indexed and queried as their own governed steps.

Capture intake, including voice transcripts. Material from outside a hand-written page flows in through one capture intake: uploaded documents, messages, notes, ambient capture, and voice transcripts all land in the same capture store, redacted at ingest and fanned out to the index. You list captures by their source type, so the workspace’s transcripts (and the rest of the captured material) are a single, searchable place rather than scattered across features.

Rendered output and form fill. A document renders to DOCX or PDF, and a rendered generation is an audited snapshot you can fetch back with the template, mode, and model that produced it on the record. A PDF AcroForm can be filled from the data the matter already holds, so a finished, fillable document comes out the far end of the same pipeline.

How you use it

Browse the tree. Open the documents panel and the page tree shows the workspace’s top-level documents; expand a folder to load its children, and click a page to open it in the reader beside the list.

Read and edit a page. Select a document to read its content, then edit it in place. Each edit lands as a new version with the previous one retained, so the page moves forward without losing where it has been.

Comment on a document. Add a note or, on a PDF, anchor an annotation to a point on the page (a box, an arrow, a comment). Read the annotations back during review and remove them when they are resolved.

Share it and set what is visible. Share a page with a colleague and choose how much of the object they can see. The grant is recorded, so access into the knowledge base is always auditable.

Follow what matters and see who else is in it. Favourite or follow the pages you care about to keep a durable list, and check presence to see who is currently reading a document.

Find anything. Run a single search across the workspace and get results merged from semantic and keyword matching, reaching documents, matters, and parties at once. Filter captures by source type when you are looking specifically for a transcript, an uploaded document, a message, or a note.

Curate the know-how. Propose a knowledge entry, send it through review, and publish it once it is signed off. When guidance changes, supersede the old entry rather than deleting it, so the record of what was authoritative when is kept intact.

Take it out. Render a document to DOCX or PDF, fetch the audited generation snapshot, or fill a PDF form from the matter’s data.

The kernel verbs behind it

Everything above runs through the kernel’s one front door: each call is permission-checked and audited before it executes. These are the key verbs.

Pages and the tree:

  • doc.list - list documents (metadata only); the parent-and-children listing that builds the page tree.
  • doc.get - open a document and read its canonical content body.
  • doc.edit - edit a page in place through the governed write path.
  • doc.version - the version chain behind a document; old versions are retained, not overwritten.
  • doc.annotate - add a note or a page-geometry annotation (box, arrow, comment) to a document.
  • doc.share - give another person access to a document.
  • object.visibility.set - set how visible an object is to those who can reach it.

Following and presence:

Search, embeddings, and capture:

  • search.query - unified retrieval over Postgres, vector and lexical merged together over a two-tier index.
  • embed.index - index content for semantic retrieval.
  • embed.query - run a semantic query against the index.
  • capture.ingest - ambient and transcript capture into the workspace, redacted at ingest and fanned out to the index.
  • capture.list - list captures by source type: the home of voice transcripts and document, message, note, and other captures.

Curated know-how:

Rendered output and forms:

  • generated.get - fetch an audited rendered generation with its template, mode, and model.
  • acroform.fill - fill a PDF AcroForm from the data the matter holds.

See the full set across the doc, knowledge, engagement, and capture verb references.