Big companies build the same thing over and over, because most engineers, and their
coding agents, can only see their own team's code. Ask HomeGrown before you build. It
tells you what already exists, who to ask about it, how ready it is and how to get it,
even when the code is in a repository you can't open.
A real answer from a test run on Grafana's public repositories. Public code has no org chart, so the teams, people, leads and access rules in that test are generated.
Two agents share one PostgreSQL database. A collector keeps a record of every component
as repositories change; an answerer searches it as the person asking, so row-level
security decides what each person sees. The website
has the full tour.
Try it
You need Docker, Python 3.12+ and Git, and a read-only GitHub token.
git clone https://github.com/tancred27/home-grown.git && cd home-grown
cp .env.example .env
docker compose up -d # PostgreSQL with pgvector
python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -e ".[dev]"
# collect one organization (pallets is small and public)
echo "HOMEGROWN_GITHUB_TOKEN_FILE=/path/to/github-token.txt" >> .env
python -I scripts/sync_worker.py pallets --once
# ask
homegrown add-user alice && export HOMEGROWN_USER=alice
homegrown ask "has anyone built signed tokens that expire, for password reset links?"
Without a model, HomeGrown answers from the evidence alone and says "possibly" rather
than "yes".
.env.example starts with no model. Set HOMEGROWN_VERDICT_MODE=model in .env, plus one of:
# pick one
HOMEGROWN_LLM_PROVIDER=anthropic # with ANTHROPIC_API_KEY
HOMEGROWN_LLM_PROVIDER=groq # with GROQ_API_KEY or HOMEGROWN_GROQ_KEY_FILE
HOMEGROWN_LLM_PROVIDER=gemini # with GEMINI_API_KEY or HOMEGROWN_GEMINI_KEY_FILE
HOMEGROWN_LLM_PROVIDER=local # with HOMEGROWN_LLM_BASE_URL and HOMEGROWN_LLM_MODEL (e.g. Ollama)
The judge was tested with Claude Opus (HOMEGROWN_JUDGE_MODEL=claude-opus-5-5, the default).
With another provider, set HOMEGROWN_JUDGE_MODEL to a model it serves. With a local model,
nothing leaves your machines. Free hosted tiers may train on your prompts, so don't send
private code to them. More in docs/configuration.md.
READMEs go stale; code doesn't. With the code reader on, each sync also reads the source,
summarises it area by area with a cheap model, and splits each repository into the
services, libraries, tools and integrations inside it, each with its own description.
HOMEGROWN_CRAWL_ENABLED=true
HOMEGROWN_CRAWL_SUMMARY_MODEL=claude-haiku-5-5 # one short call per changed code area
HOMEGROWN_CRAWL_COMPILE_MODEL=claude-sonnet-5-5 # one call per repository
Only short extracts go to the model: function and type declarations and their comments,
with anything that looks like a key, token, password or internal hostname removed first.
Unchanged code is never re-read or re-summarised.
Who to ask. Each result names up to two people: its most recent committers who are
in your company directory, each with their manager and when they last committed. Load the
directory with homegrown directory import people.json (a snapshot of id, name, team,
manager, line of business, active flag, emails and logins; emails and logins are stored
only as hashes). Without a directory, it names the owning team's lead.
A question back. When a request leaves open something that changes the best answer
(which cloud, which language, a library or a running service), the answer ends with one
short question and its choices. Ask again with your choice added.
Why that answer? Every answer has an id. homegrown find prints it, and
homegrown explain <id> shows each step: which words and fields matched, how results were
ranked, what the judge decided and why, and which code each result came from. Only the
person who asked can see it.
Dashboard: run uvicorn homegrown.api:app --port 8080 and open
http://localhost:8080/ui. There's no real sign-in yet: you type a user name, which is
fine on your own machine and not for a shared server.
Use it from your coding agent
HomeGrown is an MCP server:
claude mcp add homegrown -e HOMEGROWN_USER=alice -- /path/to/.venv/bin/python -m homegrown.mcp_server
Agents call find_existing before writing new code. Each match says whether the person
asking can read its code; when they can't, the agent names the owner and offers to ask
for access instead of writing a copy. The explain tool shows why a result came back.
Duplicates across teams (opt-in)
With HOMEGROWN_DUPLICATES_ENABLED=true, homegrown duplicates --run finds units owned
by different teams that do the same job and groups them, for admins listed in
HOMEGROWN_ADMIN_USERS to confirm or reject. Nothing is deleted or deprecated. It is off
by default; see How it works.
How well it works
Tested on real public code from Grafana, Microsoft, Google, AWS and others, with the
product as it ships:
- 94% of first answers rated good or okay (70% good, 6% bad) on 92 fresh questions
written the way engineers and coding agents ask, and 0 results wrongly labelled
"use as-is".
- Up to 92%: the right component is in search's top 5 among 5,000 components (85% on
test questions, 92% on the same questions in casual wording).
- 100% of known look-alikes across teams found by the duplicates job (20 of 20 pairs),
and 9 of 9 sampled groups confirmed by a reviewer.
- 16 to 3: how often a blind reviewer preferred the current judge's answers to an
earlier judge's.
- 0.1 s to search 100,000 components (300,000 vectors) with permission checks on, and
under 4 minutes from a push to searchable, 95% of the time.
The 85–92% uses component profiles that AI models wrote during testing; the code reader's
own profiles reach the judge's shortlist less often (62–65%). No company runs HomeGrown in
production yet. Every number and known limit is in docs/results.md;
what's next is in VISION.md.
Docs
How it works · Settings ·
Connecting GitHub · Running it for a company ·
Traces and metrics · Results and limits
Contributing
Contributions are welcome. Start with CONTRIBUTING.md, and report
security problems privately as described in SECURITY.md.
Licensed under Apache-2.0.
