Product

Navigate, don’t retrieve.

This is the machine behind the numbers: ten typed tools with hard token budgets, a zero-LLM path for the easy questions, an ingestion pipeline that turns spreadsheets into queryable datasets, and an MCP surface any agent harness can hold.

Deploy your forest Read the research

The Vine

Ten primitives, every observation budgeted

The agent touches the forest exclusively through these. Every read carries a hard output budget with explicit truncation (`truncated: true`, never a silent cut), so an agent can always distinguish “not there” from “cut off”.

Primitive	Budget	What it does
`locate(query, k)`Read	≤ 800 tokens	Ranked entry points over curated metadata only. BM25 over SQLite FTS5, scent-weighted title : aliases : tags : summary at 4 : 3 : 2 : 1; hybrid with vectors under RRF when a Canopy index exists.
`look(id)`Read	≤ 500 tokens	A node’s digest: summary, tags, outline and its top twelve edges, each carrying a twenty-five-token scent of the neighbour it points at.
`move(id, rel?)`Read	≤ 600 tokens	Traversal along a typed edge to the neighbours on the other side.
`pick(id, section?)`Read	≤ 4 000 tokens	Read a body. Anything larger than the budget returns its outline instead, steering the agent to choose one section rather than being cut mid-sentence.
`sniff(terms)`Read	≤ 800 tokens	Literal, diacritics-normalised grep over bodies only: the other half of the normative locate/sniff split.
`scan(parent, filter)`Read	≤ 800 tokens	Metadata filtering across a whole region, with zero file opens. How a wide question gets narrowed cheaply.
`query(id, sql)`Read	200 rows / 2 s	Read-only SQL over a dataset node, injection-hardened. Every write is rejected; datasets are born from a declarative schema validated by the Vine, so the model never writes DDL.
`plant`Write	atomic	Births a node with a contract-checked passport. One git commit.
`graft`Write	atomic	Creates or reinforces a typed edge, under a reinforce-before-create rule that never duplicates. One git commit.
`tend`Write	atomic	Mutates one node: passport, links, or exactly one INSERT/UPDATE/DELETE with a mandatory WHERE and no DDL, ever. One git commit.

The locate/sniff split is normative: `locate` searches only curated metadata, `sniff` only raw bodies. That separation is what makes the value of curation measurable, and what keeps entry search at 1.3 ms p95 with no embedder anywhere.

A typical hop costs 200-500 tokens of observation. A five-hop answer costs roughly 1.5-2.5k tokens of exactly relevant context, against a top-k stuffing of comparable size whose relevance was a bet placed before reading anything.

The cheap paths

Not every question deserves a hunt

Navigation pays per hop. On shallow questions a one-shot path is faster and adequate, which is exactly why it exists, and why the deployment rule is written down instead of implied.

harvest: zero-LLM retrieval
`locate` and `sniff` fused by Reciprocal Rank Fusion, then a selective `pick`, all within a 4 000-token budget. Pure machine time: no model call at all. Measured at roughly 50 ms median for a ~1.3k-token evidence bundle.
answer: grounded, with its sources
The one call that costs real money. It arrives with the node ids it stands on, so “what was this answer built from” is a list you can open, not a similarity score.
The answer store
Per forest, on by default. Retrieval still runs on every ask; a stored reply is served only while the material behind it is byte-for-byte what it was, so a stale hit is structurally impossible and any write invalidates every earlier entry. A served answer says so, and the audit row records the cost avoided.

The deployment rule that falls out of the measurements: route through one-shot harvest first, and escalate to the navigating agent when the answer smells aggregate or the bundle comes back dry.

Ingestion

Anything you feed it becomes navigable

You do not prepare your files for the engine. You hand them over and the Gardener converts, summarises and commits each one: from the command line, from the console, or from your browser, through the same pipeline.

What you drop in	What it becomes
.md · .markdown · .txt	a note: the text is already the body
.docx	a document: headings and paragraphs as markdown
.pdf	a document, through a one-line converter hook using any CLI extractor you already trust
.csv	a dataset: a real SQLite table, queried with read-only SQL
.json	a dataset when it is a flat table, otherwise a document holding the JSON
.xlsx · .xls	a dataset per sheet, with column types inferred
.db · .sqlite · .sqlite3	adopted whole: the database becomes the payload, with a generated query manual and sample rows
.png · .jpg · .gif · .webp	a media node; with a vision model bound, also a written description that search can find
.mp3 · .wav · .m4a · .ogg · .flac	a media node carrying its passport
anything else	listed as unsupported in the report, by name, so you can see exactly what did not land

Spreadsheets stop being documents

A spreadsheet becomes a table an agent queries in SQL, with a `## Query manual` and sample rows written into its passport, so a model knows which tables and columns exist before it asks. What they mean is the one thing a machine cannot infer, so a person writes it in a `## Notes` section that travels with the dataset everywhere it is read.

Measured, not asserted

On a 100-document heterogeneous dump with a 12B curator: 100 nodes planted under a mirrored eight-branch hierarchy, 100% of summaries passing the sixty-token scent contract, zero broken links, zero lint errors, 1.71 s per document end to end. Building a forest does not require a frontier model either.

The Ingest console: sending files into a forest as a job you can watch — Drop files, mirror a whole folder the host can read, or write a document in place. Nothing is chunked and forgotten: every document becomes a node with a name, a summary and edges.

The Ranger keeps it healthy

Maintenance is a pass you can schedule, not a daemon to babysit. Heat evaporates on a thirty-day half-life; agent-discovered shortcuts get promoted when both endpoints are hot, or pruned when they go stone cold; sources that vanished are flagged stale instead of deleted.

Confidence has a lifecycle: 1.0 structural or human and untouchable, 0.8 promoted, 0.5 an agent-discovered shortcut, 0.3 a curator proposal at ingest.
Promotion and pruning happen only below 1.0, and every change is an audited commit.
The Ranger never deletes nodes.

The Troop: parallel foragers and a judge

For hard questions, three to five monkeys hunt in parallel from distinct entry points, share session-scoped heat as they go, and a judge synthesises their candidates. A patience policy (keep hunting while harvests still surface new nodes, stop after a few dry rounds) replaces oracle knowledge of how wide a question forks.

The honest result

The troop is an accuracy amplifier, not a speed one. 11/11 against 10/11 solo on single-chain questions and 8/8 against 7/8 on fork-tier ones, at 2.3× the tokens and 3.3× the wall clock. The speedup hypothesis failed cleanly, and the post-mortem is written down in the paper rather than dropped.

The management layer

Ten consoles over one API

The Studio is where people watch, govern and teach the forest. Every console calls the same `/v1` routes any client could call: there is no privileged path, and no separate super-administrator panel.

Overview
What is in this forest, and what your key may do here.
Ask
Answers that arrive with the nodes they stand on.
Explore
The tree as a living graph, walked node by node.
Data
Read-only SQL over dataset nodes, with the query manual beside it.
Ingest
Files, folders and clips, as a job you can watch.
Access
One row per person: level, scope, sign-in and live tokens.
Models
Bindings, budgets and the answer store’s running score.
Health
What the forest needs, before it needs it.
Skills
The instruction file that makes this forest your agent’s memory.
Integrations
The exact snippets for this deployment, address already filled in.

Integration

It speaks MCP to whatever you already run

The MCP surface is contract-identical to a local `vine serve`: an agent that works against a forest on your own disk works against a Station-served forest with no change beyond the endpoint and a credential. Scoping only ever narrows content; it never changes the shape of a response.

Surface	Who it serves	Where
Studio	Humans: the web console	https://station.example.com/
REST	Apps, scripts and integrations	https://station.example.com/v1/…
MCP	Any agent harness (streamable HTTP)	https://station.example.com/mcp/

Terminal

vine serve --forest ./brain                    # stdio MCP server
vine serve --forest ./brain --transport http   # or over HTTP

Claude Code and any MCP-capable runtime hold the forest’s ten tools directly: no host, no accounts, your ecosystem.
The Skills console generates the instruction file for this exact deployment, so an agent learns to use the forest as persistent memory.
A key you pair for an agent can only narrow your access, never add to it.

One tool list, not a second stack

Registering a forest does not ask you to retire anything. It takes a slot beside the servers you already run, and the agent routes between them with every tool description in front of it. The vector store, the SQL tool, the graph and the fusion layer of the hybrid design people sketch are already primitives on this one endpoint.

See the hybrid design, box by box

Architecture

Four layers, one direction of dependency

The Station is a privileged client of the engine, not an extension: the engine gains nothing and loses nothing from its existence. That is why the license split along the same line is enforceable.

Diagram: agents, console and API clients meet one gate; the gate drives an untouched engine; the engine owns the forest, and the forest owns its own git history.

Run it before you believe it.

The repository builds a fixture forest and reproduces every table in the paper. When you are past that, we sell the parts you should not have to build yourself.

Deploy your forest See support plans

Navigate, don’t retrieve.

Ten primitives, every observation budgeted

Not every question deserves a hunt

harvest: zero-LLM retrieval

answer: grounded, with its sources

The answer store

Anything you feed it becomes navigable

Spreadsheets stop being documents

Measured, not asserted

The Ranger keeps it healthy

The Troop: parallel foragers and a judge

The honest result

Ten consoles over one API

Overview

Ask

Explore

Data

Ingest

Access

Models

Health

Skills

Integrations

It speaks MCP to whatever you already run

One tool list, not a second stack

Four layers, one direction of dependency

Run it before you believe it.