KnowIt — Shared team memory for AI coding agents

Stop re-explaining your codebase.

Without KnowIt

Your agent asks how Stripe webhooks should be handled. You explain. Next session, same question.
A new teammate's agent introduces a naming pattern you deprecated six months ago.
Three agents working on the same codebase hold three inconsistent models of the architecture.

With KnowIt

Agent calls resolve_context before planning. It finds the idempotency rule. It starts informed.
Every convention is immediately searchable by every agent on the team.
At session end, the agent persists everything it discovered.

"The problem is not your agents. It is that their memory resets every session."

Set up in three steps.

Create the knowledge base.

Run knowit init. A local SQLite database is created. No server, no account, no API key.

knowit init

Register with your agent.

Works with Claude Code, Codex, Cursor, Windsurf, and any MCP-compatible client. Pick yours:

claude mcp add -s user \
  -e KNOWIT_DB_PATH="$HOME/.knowit/knowit.db" \
  knowit -- knowit serve

codex mcp add knowit \
  --env KNOWIT_DB_PATH="$HOME/.knowit/knowit.db" \
  -- knowit serve

// ~/.cursor/mcp.json · windsurf · zed · any MCP client
{
  "mcpServers": {
    "knowit": {
      "command": "knowit",
      "args": ["serve"],
      "env": {
        "KNOWIT_DB_PATH": "/Users/you/.knowit/knowit.db"
      }
    }
  }
}

Agents read context. They remember what they find.

Two lines in your CLAUDE.md is all it takes. From here, every session starts informed.

# CLAUDE.md
Before planning, call resolve_context.
After completing, call capture_session_learnings.

You don't change how you work.

No special syntax. No commands to memorize. Just tell your agent what you need.

Before planning

"Resolve context from KnowIt before you start on the payments retry feature."

After a session

"Save what you learned to KnowIt: the auth token edge case and the retry pattern we landed on."

Mid-session lookup

"Search KnowIt for how we handle Stripe webhook failures."

Capturing a decision

"Store this in KnowIt: we use JWT for auth, not session cookies. Scope it to the auth-service repo."

Built for teams, not just individuals.

Structured knowledge model

Types (rule, architecture, pattern, decision, convention, note), scopes (global, team, repo, domain), and confidence scores. Not flat markdown.

Shared team memory

One database, every agent on the team. Knowledge stored by one developer's agent is available to every other agent immediately.

MCP-native

Works with Claude Code, Codex, Cursor, and any MCP-compatible agent. A first-class MCP server, not a wrapper.

Semantic search

Provide your OpenAI API key for embedding-based semantic search. Without it, text and tag matching works out of the box.

Source orchestration

Connect Notion, Obsidian, or any MCP source. KnowIt's routing layer directs your agent to the right place for every read and write. After an external read, a distilled copy flows back into KnowIt automatically.

Local-first

SQLite. Your team's knowledge lives on your infrastructure. No account, no cloud dependency, no data leaving your machines.

Every entry is structured.

Not a flat file. Not a markdown blob. Typed, scoped, and scored.

Type	Title	Scope	Confidence
rule	Stripe webhook idempotency	`repo:payments-api`	0.95
architecture	Repository layer pattern	`repo:api-gateway`	0.90
decision	JWT over session cookies	`repo:auth-service`	0.85
pattern	Payment retry with server state	`repo:payments-api`	0.90
convention	kebab-case for all route files	`team`	1.00
decision	Postgres for transactional data	`team`	0.90
rule	No direct DB access from controllers	`repo:api-gateway`	1.00
note	Auth token expiry edge case (open question)	`repo:auth-service`	0.60

rule0.95

Stripe webhook idempotency

repo:payments-api

architecture0.90

Repository layer pattern

repo:api-gateway

decision0.85

JWT over session cookies

repo:auth-service

pattern0.90

Payment retry with server state

repo:payments-api

convention1.00

kebab-case for all route files

team

decision0.90

Postgres for transactional data

team

rule1.00

No direct DB access from controllers

repo:api-gateway

note0.60

Auth token expiry edge case (open question)

repo:auth-service

Connect to where your knowledge lives.

Point KnowIt at Notion or any MCP-compatible source. Your agent queries once and KnowIt routes reads and writes to the right place.

Notion Available

Custom MCP source Available

More integrations Coming soon

Agent queries KnowIt

KnowIt routes the request

SQLite or Notion responds

See routing response schema

Agent calls the same tool every time

resolve_source_action({
  action:        "read",
  artifactType:  "decision",
  query:         "authentication strategy for the API",
  repo:          "auth-service"
})

mode: "local" SQLite · default

{
  mode:                  "local",
  shouldUseKnowitDirectly: true,
  mcpServerName:         null,
  nextStep:              "Read the decision
                          directly from Knowit.",
  storeDistilledMemory:  false,
  relevantKnowledge:     [/* 3 matches */]
}

Agent reads directly from KnowIt
Relevant local context returned

mode: "route" Notion · connected

{
  mode:                  "route",
  shouldUseKnowitDirectly: false,
  mcpServerName:         "notion",
  nextStep:              "Use the notion MCP next
                          to read the canonical
                          decision.",
  storeDistilledMemory:  true,
  relevantKnowledge:     [/* bonus ctx */]
}

Agent is told to call Notion MCP next
storeDistilledMemory: true flows a distilled copy back to KnowIt

Connect Notion in one command:

knowit source connect notion

One memory. The whole team.

Point every developer's agent at the same database. What one agent stores, every other agent finds instantly. No sync step, no duplication.

alice · Claude Code stored rule Stripe webhook idempotency repo:payments-api just now

bob · Codex read rule Stripe webhook idempotency repo:payments-api 1m ago

bob · Codex stored pattern Payment retry with server state repo:payments-api 3m ago

carol · Cursor stored convention kebab-case for all route files team 5m ago

alice · Claude Code read pattern Payment retry with server state repo:payments-api 8m ago

carol · Cursor stored decision JWT over session cookies repo:auth-service 12m ago

Ready in 30 seconds.

One command to install. One to register your agent. Done.

npm install -g knowit && knowit init

Then register your agent in step 2 above ↑

Read the docs on GitHub →

Your agents remember.