v1.9 · shared team memory

Give AI your
team's memory.

Hunch gives every coding agent the decisions, trade-offs, and hard-won lessons behind your code—so each session starts with what your team already knows.

Get started See how it works

a familiar story

The bug was fixed. The reason was not.

A non-obvious safeguard survives in the code. The story behind it slowly disappears.

Monday

A team solves a painful logout bug.

They move sessions server-side so a leaked token can be revoked immediately. The choice adds complexity, but it closes the hole.

Months later

The code remains. The context fades.

The incident is buried in an old pull request. Two people have changed teams. The unusual session flow now looks like needless machinery.

Next session

An AI assistant offers to “simplify” it.

The change is tidy and locally correct. It also reopens the exact failure the team already paid to understand.

With Hunch

The reason arrives before the edit.

The assistant sees what was chosen, what was rejected, and which bug the choice prevents. It takes a better path without asking the team to retell the story.

what changes

Your assistant starts with the team's memory.

Hunch learns from normal engineering work, then brings the relevant part back at the moment it matters.

01 / remember

Work leaves a trail.

Commits, test failures, and your corrections become durable decisions, bugs, and rules—without a separate documentation ritual.

02 / recall

The right context shows up.

Before changing a file, the assistant sees why it is shaped this way, what depends on it, and what has failed there before.

03 / protect

Old mistakes stay learned.

Hunch quietly flags a reversal and explains why. You decide what happens next; blocking is opt-in.

under the hood

Local at the core. Precise when it matters.

The friendly story is backed by a deterministic code graph and plain, reviewable records. Hunch can explain its answer—and show the evidence behind it.

.hunch/team.json

Git-native memory

Keep memory beside the code or connect the whole team to one dedicated private Git repository. Fresh clones discover it from a credential-free pointer.

code graph

Real blast radius

Symbols, callers, components, and dependencies connect the reason to the code it governs.

MCP + rules

Works across assistants

Claude Code, Cursor, VS Code, Windsurf, Codex, and others read from the same memory.

conformance

Deterministic checks

Layering, must-reach paths, rejected approaches, and known regressions are checked without an LLM verdict.

provenance

Receipts, not guesses

Every answer carries its source, confidence, commit, and the history behind the recommendation.

local-first

Your memory stays yours

No SaaS is required. Private reasoning can live in a separate overlay you control.

That is the short version. Explore the architecture and full feature set →

get started

Give your next AI session a memory.

Install and initialize

One command indexes the repository, connects supported assistants, and keeps the memory beside your code.

Bring the recent past with you

hunch backfill --since 90d turns recent history into a useful day-one memory.

Ask a real question

Try “why is the session module built this way?” Your assistant answers from the team's history, with evidence.

Claude CodeCursorVS CodeWindsurfCodexAntigravityAGENTS.md

~/your-repo

# install from npm — Node 22.13+
$ npm install -g @davesheffer/hunch

# index + hooks + wire up every assistant
$ cd your-repo && hunch init

# cold start: seed decisions from history
$ hunch backfill --since 90d

# the "why" behind any file or symbol
$ hunch why src/auth/session.ts

npm i -g @davesheffer/hunch && hunch init

Claude Code? Install as a plugin instead:
/plugin marketplace add davesheffer/hunch → /plugin install hunch@hunch
Open VSX

Make your codebase remember why.

Keep the decisions your team already made available to every person and every assistant that comes next.

Get started Read the docs