Meshly Build / Knowledge

Your agents remember what they learned.

Build writes down what it learns, files it at the right scope and gives the next agent a head start.

Most agent tools start every session cold, so the architecture stays a black box and the same questions get asked twice. In Build, architecture maps, project docs, decisions and shared memory stay with the project, and every agent reaches them over MCP.

Architecture mapsDecisionsShared memoryEvidence grades

Detail 01, architecture maps

Station generates eight sections for every project.

Station reads your repository and produces one structured description of the project, which the backend stores and renders from. Nothing calls a model at render time, so the same source always draws the same view.

No.Section
01Overview
02Tech stack
03Entry points
04Architecture
05Surfaces
06Data model
07Integrations
08File tour
Freshness
Every scan records the commit it read and its confidence for each section.You can tell a fresh map from an old one at a glance
Diagrams
Build derives the diagrams directly from the source, so they do not hallucinate.
Rescan
You can ask for a rescan from the UI. The next available Station picks up the request and posts a new description back.

Detail 02, project docs

Long-form documentation stays accountable to your code.

Each project has a store that agents write to and read from, and it holds five kinds of document: the genome (what this project is and how it is built), Mermaid diagrams, long-form prose, external references and environment docs. Agents reach all of it over MCP. Whatever one agent works out is ready for the next one, and nobody has to write a wiki page.

Agent writes
An agent writes down what it learned about the codebase as it goes.MCP: upsert_genome, record_module_map
Environment
Environment docs hold only references and non-secret config.Secret values never live here
Corrections
The web app gives you full read, write and delete access.Anything an agent got wrong is yours to correct

Detail 03, decisions

Decision records stay current.

Decisions are first-class records, which are tied to the tasks that produced them and can be queried over MCP. The reason a thing is the way it is stays on record when the engineer who wrote it leaves.

Links
Every decision links to the tasks that produced it.
MCP
Decisions are available to every agent over MCP.record_decision, search_decisions, update_decision
Search
Semantic search finds the relevant decision when an agent picks up adjacent work.

Detail 04, shared agent memory

Memory follows the work wherever it runs.

Memory lives on the server in four types, and each memory is scoped to the workspace, a project or an agent. Stale local memory files clean themselves up, and the agent on a developer laptop shares the same memory as the agent in CI.

Types
Build stores user, feedback, project and reference memories.They hold the user profile, feedback, project context and external references
Scopes
Memories are scoped to the workspace, the project or the agent. You write each one once at the right scope, and it can be read everywhere.
MCP
Agents curate their own context.save_memory, list_memories, forget_memory
Approval
Agents can propose workspace-wide memories.A workspace Admin approves, edits or rejects each one before any agent sees it

Detail 05, memory trust

The board can overrule a memory.

Every memory records what it came from and when, so the platform notices when the board contradicts it. When a task is reopened from Done or rejected, the memories that leaned on it are killed, and a rename marks them as suspect.

The check runs at the moment an agent reads a memory, so the platform never waits for a nightly sweep. A memory that the work has already disproved never reaches the next session.

Provenance
Memories carry the tasks, decisions and epics they came from.
Contradicted
A contradicted memory is dropped.
Doubtful
A doubtful memory is served wrapped in the action that cast doubt on it.That way it gets checked before it gets trusted
Signals
The board endpoints stay unchanged.The signals come from the activity stream that the platform already keeps

Detail 06, evidence grades

Each entry says how well it is known.

Every knowledge entry carries a grade, written in words beside the entry. An agent can tell a claim that was read against the code from one that a single session reported, and it can weigh each one to match. The agent is told in plain words what the grade means, so the grade is never a hidden number.

GradeMeaning
UnverifiedOne session reported it, and nobody has checked it.
CorroboratedLater sessions used it, and none contradicted it.
CuratedAn agent with a checkout affirmed it against the code.
VerifiedSomething outside the session that wrote it vouched for it.
Checking
Checking an entry means opening the files it names.Build refuses a verdict of holds unless it comes with the paths that were read and the commit they were read at. A verdict with no evidence is only an opinion about the wording.
Fall back
A curated grade falls back when commits land after the commit it was checked at.Rewriting an entry also reopens it. Neither event retires the entry, because nobody has shown the claim to be wrong.
Schedule
Station can run the check on a timer.The timer is off by default and is set per project. The control shows the cost of a run before you switch it on.

Detail 07, the learning loop

The system gets sharper as it works.

Approvals reinforce the matching knowledge entries, and entries that nobody touches decay. Coverage gives the share of finished tasks that carry a knowledge entry, and it shows the counts behind the percentage so you can check it. Capability profiles track which task types and labels each agent has handled.

Confidence
Confidence rises on approval and decays without reinforcement.Each signal adds +0.1, and confidence is capped at 0.95
Staleness
Build recognises six distinct staleness reasons, and each one has its own suggested action.An entry that is still in demand is proposed for revalidation and is never archived on age alone
Profiles
Profiles track each agent’s performance by label over rolling windows.They help with routing and with sizing custom agents
Lessons
Your own Station distils lessons from review feedback, using your own Claude Code or Codex.Build serves those lessons to the next agent that does similar work

Comparison

You can replace the runner and keep the knowledge.

Build keeps the knowledge above the runner. When you move between Claude Code and Codex, or on to the next tool, the knowledge stays with you.

Without BuildWith Build
Cold-start agents search the repository to find context.Warm-start agents arrive with the architecture already summarised.
The same architecture question gets asked every week.Decisions can be queried, and they appear when they are relevant.
Hand-written docs drift the moment they ship.The board can overrule memory, so disproved context stops being served.
Lessons learned live in retro notes that nobody reads again.Memory and capability profiles compound across machines and sessions.
Changing models means learning the codebase again.When you change models, the knowledge stays, because it lives above the runner.

Related sheets

See it on your own codebase.

Point Station at your repository, and Build keeps an architecture map, a decision log and a shared memory that the next agent inherits. Tell us about your setup, and we will walk through it with your project.

One level deeper

Control covers guardrails, access levels and budgets.

Approval gates, automated review, budgets and access levels keep agent work in line.

Open Control