Knowit — shared, structured memory for AI coding agents

Every new agent session starts from zero. The architecture rules you explained yesterday, the naming conventions your team agreed on, the decision you made three weeks ago about why controllers never touch the database — all of it is gone the moment the context window closes.

Knowit fixes that. You store engineering knowledge once, as structured entries, and every agent retrieves the relevant context before it plans or edits code. Memory lives with your project, not with any single tool.

Why Knowit

• Same context, every session. Agents call resolve_context before changing code, so each session starts with the project rules and decisions that matter for the task at hand.
• Structured, not scattered. Knowledge is stored as typed entries (rules, architecture, patterns, decisions, conventions, notes) with scopes, tags, and metadata — not as prose buried in prompt files.
• Shared across the team. Project memory lives in a git-friendly JSONL file (.knowit/knowledge.jsonl) that you review like source code, or in a shared SQLite database when you want memory outside the repo.
• Agent-agnostic. Knowit is an MCP server. It works with Claude Code, Codex, Cursor, Windsurf, VS Code / GitHub Copilot, Gemini CLI, Kiro, Cline, Continue, Zed, JetBrains AI Assistant, and anything else that speaks MCP.
• Local-first and open source. MIT licensed. Your memory is a file in your repo or a database on your disk — no hosted dependency required.

Why structured memory

Knowit is built for operational engineering memory: the durable context agents need while doing code work. Every entry carries structure:

• an entry type: rule, architecture, pattern, decision, convention, or note
• a scope: global, team, repo, or domain
• metadata: tags, URLs, confidence scores, and source information
• renderable body blocks: headings, paragraphs, lists, quotes, code, callouts, and link lists

That structure is what lets an agent retrieve only what matters: repo-specific architecture rules before implementing a feature, domain conventions before refactoring a subsystem, or team-wide decisions before introducing a new pattern.

Where things live

Canonical source code stays in the repository. Durable engineering memory stays in Knowit. External canonical docs can stay in tools like Notion, with Knowit routing agents to the right source when needed.