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.
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 |
|---|---|
| 01 | Overview |
| 02 | Tech stack |
| 03 | Entry points |
| 04 | Architecture |
| 05 | Surfaces |
| 06 | Data model |
| 07 | Integrations |
| 08 | File 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.
| Grade | Meaning |
|---|---|
| Unverified | One session reported it, and nobody has checked it. |
| Corroborated | Later sessions used it, and none contradicted it. |
| Curated | An agent with a checkout affirmed it against the code. |
| Verified | Something 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 Build | With 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