Old summaries sound current
A stale note can be fluent, relevant, and wrong after the code changes.
// free Apache-2.0 trust layer for coding agents
AI coding agents need more than memory. They need a trust layer.
.knowledge lives inside your repository and tells connected coding agents what to read, what is evidence-backed, what is stale, what needs repair, and what a reviewer should verify before merge.
Current code and tests remain the source of truth. External memory stays advisory.
routing evidence trust freshness repair PR review local Inspector agent integrations advisory memory status
install artifact release asset
[ 1 ] download the latest release asset,
not the source snapshot
[ 2 ] unzip the release asset at repo root
[ 3 ] tell the agent to read Quick-Start.md
[ 4 ] the system opens Inspector for chat behavior tuning// the adoption gap
AI adoption is mainstream. Trust is not.
These figures describe developer sentiment and workflow plans, not .knowledge
product performance.
- AI tools
- 84% use or plan to use AI tools
- Accuracy trust
- 46% distrust the accuracy of AI output
- Commit/review
- 58.7% do not plan to use AI for committing and reviewing code
Source: Stack Overflow Developer Survey 2025.
.knowledge exists to change these numbers. Its mission is to make AI-assisted repository work trustworthy enough to review, commit, and merge with evidence instead of guesswork.
// problem
Agents do not fail only because they lack context.
They fail because context has no trust state.
Memory can outrank evidence
Retrieved context is useful, but it should never silently override current code and tests.
Repo drift becomes invisible debt
Documentation, module cards, decisions, and handoffs decay at different speeds.
PR risk arrives too late
A diff shows changed lines. It does not show which trust boundary or stale knowledge was affected.
Teams cannot explain agent decisions
Without evidence and freshness metadata, reviewers cannot see why an agent believed something.
// agent compatibility
One trust layer. Multiple coding agents.
different agents, same trust rules one shared repository map parallel work across multiple agents visible handoff processes no fragmentation between chats
// read next
Decision layer on the site. Proof layer on GitHub.
The website explains what .knowledge is, why it matters, and how to decide.
GitHub keeps the release asset, source, CLI, tests, schemas, validators, fixtures, and exact commands.
evergreen docs
Install and operate .knowledge
Release asset rule, trust model, generated artifacts, integrations, memory providers, Inspector, embedding, and compatibility.
technical notesResearch, comparisons, and design decisions
Benchmarks, real cases, memory vs trust layer, graph explanation, release hygiene, and agent workflow notes.
install artifactDownload on GitHub
Do not use GitHub Code > Download ZIP as the install package. Use the uploaded GitHub Release asset only.
proofInspect source and validators
GitHub is the implementation reference for reproducible checks, exact commands, release gates, and package validation.
// docs
The docs answer how to use it.
install
Install .knowledge
Install from the uploaded Release asset, unzip it at the repository root, then ask your coding agent to read .knowledge/Quick-Start.md.
installRelease asset rule
GitHub source snapshots are useful for reading source. They are not the release package users should install.
trustTrust model
Code and tests stay above summaries, wiki pages, handoffs, and external memory. Trust labels tell agents how much rechecking is required.
integrationsAgent integrations
.knowledge installs only the selected or detected runtime integration by default. The full integration set is available with --all.
memoryMemory providers
Mem0 and Pinecone are free/core advisory integrations. External memory can help recall context, but it never outranks current code, tests, or evidence.
embeddingEmbed .knowledge in your app
Embedding should read generated trust artifacts and run CLI checks, not bypass the source-of-truth order.
// technical notes
The technical notes answer why it matters.
core discoverability
What is repo-local knowledge routing for coding agents?
A practical definition of repo-local knowledge routing: the first-read path, artifacts, trust rules, and where .knowledge fits in an AI coding workflow.
comparisonLocal-first agent memory vs RAG for coding agents
A practical comparison of local-first agent memory and RAG for coding agents, with trust rules, artifact paths, and when each model should be used.
core discoverabilityHow to reduce repeated repo crawls by coding agents
A practical way to reduce repeated first-orientation crawls by giving coding agents one routing bundle, scoped source checks, and cautious metrics.
inspectorVisual inspector for AI coding agent trust and freshness
How a visual inspector helps teams see trust, freshness, repair work, and stale modules before agents make code changes.
// product modules
The trust layer is made of small, inspectable parts.
Routing Bundle
The compact first-read map for agents.
Evidence Ledger
Claim support that points back to real project artifacts.
Trust + Freshness
Status labels before knowledge is used.
Repair Queue
Knowledge debt as visible work.
Basic PR Review
Changed files mapped to trust boundaries.
Local Visual Inspector
Local dashboard over trust state.
Agent Integrations
Runtime-specific rule files and skills.
Mem0 / Pinecone Status
Advisory boundary checks for optional memory.
Local Search / Wiki Graph
Scoped discovery without loading everything.
// operating model
Agents execute. .knowledge verifies. Humans review.
Agents
Use the routing bundle, evidence, and current trust state.
.knowledge
Detects drift, grades freshness, records repair work, and builds PR impact.
Humans
See why knowledge is trusted, what needs recheck, and what blocks merge readiness.
Repository
Keeps the artifacts local, inspectable, and reviewable beside the code.
// visual inspector
Inspect trust before agents act on it.
The open core includes a local Inspector baseline for checking health, trust, freshness, repair work, wiki graph state, and PR-review readiness. The local Inspector is included in the free core; Inspector Pro is the waitlist/team workflow layer.
// memory providers
External memory is useful. It stays advisory.
Memory providers can help agents remember conversations and retrieved context.
.knowledge keeps that memory behind source, tests, and evidence.
Mem0 OSS
Self-hosted memory for agent conversations and context recall across different agents, kept advisory inside the trust layer.
Pinecone
Optional vector memory status for teams that already use managed retrieval infrastructure.
Graphiti + Zep
Better suited for Pro or Enterprise workflows that need graph memory, managed history, or fleet-level governance.
// FAQ
Trust-layer questions before install.
What is the source-of-truth order?
Current code first, current tests second, then evidence, modules, decisions, wiki, sessions, and external memory last.
Does .knowledge require cloud, login, or telemetry?
No. The free core is repo-local and does not require cloud sync, account login, or telemetry to run.
Is .knowledge an IDE?
No. Coding agents and editors still do the work. .knowledge provides the trust, routing, freshness, repair, and review layer beside the code.
Does it eliminate hallucinations?
No. It does not guarantee correct edits. It makes trust state, evidence gaps, stale context, and repair work visible before agents and reviewers rely on repository knowledge.
Can I install from GitHub Code > Download ZIP?
No. That download is a source snapshot. Use the uploaded Release asset only, then unzip the release asset at the repository root.
Does external memory become source of truth?
No. Code and tests beat summaries. Evidence beats prose. External memory stays advisory.