Local-first · Powered by Claude · Open source
Continuous intelligence for every repo you own.
Open-source agents scan your codebases locally, track what changed, and send you one quiet briefing. Your code never leaves your machine.
- MIT licensed
- One-command Docker setup
- 100+ specialist agents
Who it's for
For the people who own the whole picture
Built for the roles accountable for many codebases at once. Visibility without the alert fatigue.
Tech leads
Keep a finger on every repo your team owns without living in a dozen dashboards.
Chief & principal engineers
See where complexity and risk are piling up across every team's repos.
CTOs
A continuous read on engineering health. Facts, not vibes or status decks.
VPs of Product & Engineering
Cross-repo visibility and AI-planned roadmaps that connect what's happening to what's next.
A look inside
See Shire in action
Real screens from the app, running locally. Pick a category, then click through.
Point Shire at a repo and get a living scorecard — an AI overview standing on real, deterministic facts.
A repository scorecard: an AI overview over hard facts — age, commits, contributors, LOC, license and tests.
A town of specialists
Everything, in one context
Shire's agents — hobits — all read the same index of your code. Each screen answers a different question you'd otherwise chase across ten tools.
Repository intelligence
Per-repo scorecards: complexity, vulnerabilities, secrets, dead code, ownership, git history.
Repo onboarding
Point it at a fresh clone; get the architecture doc in minutes.
100+ hobits
Security, cost, debt and a hundred more, learning your taste from feedback.
Analysis & visualizations
Twenty scanners built in, rendered as dependency graphs, code-city maps and heat maps.
Briefing
One digest across every repo: what changed, what needs you. Daily and weekly.
Ask
Free-form questions about any repo, answered by reading the code.
Merge reviews & Council
Branch-pair risk analysis; or hobits debate a topic and a chair synthesizes the answer.
Roadmaps → Implement with AI
AI-planned tickets. Click Implement and review the merge request it opens.
Local-first & private
Everything runs on your machine. Claude is the only outside call.
How it works
Deep repo understanding, built in four layers.
Shire builds a four-layer model of your code. Cheap deterministic scanners run continuously; Claude reasons only over what changed.
Deterministic · continuous
Facts
Ground truth computed continuously and cheaply: lines of code, commits, contributors, dependencies, CI/CD, tests, branch and PR activity. No LLM required.
Structural
Structure
Architecture, hotspots and ownership. Where complexity concentrates, who touches what, and how the pieces fit together across every repo.
LLM-authored
Narrative
A living mental model of each codebase, written by Claude and refreshed only where the code changed.
Always-on watch
Living memory
Complexity spikes, coverage drops, a flagged dependency, a risky merge. Shire notices, remembers, and brings back only what matters.
Underneath sits a local semantic index (pgvector), so agents retrieve the right context instead of grepping blind, and a cross-repo graph that turns “this repo” into “this system.”
The roster
100+ specialists, plus the ones you write
Each hobit is a narrow expert on its own schedule. Add your own with a prompt: name it, give it a charter, set a cadence.
- security
- cost
- tech-debt
- upgrade-planner
- scalability
- architecture
- dbt
- data-quality
- streaming
- devil's-advocate council
Honest by default
What Shire is — and what it isn't
Good tools are clear about their edges. Here's the line.
What Shire IS
- A local-first companion — your repos and data stay on your machine
- Deterministic-first, deltas-only: cheap facts continuously, Claude where it counts
- A town of narrow, reliable expert agents you can configure, author and steer with feedback
- Able to implement a roadmap ticket end-to-end, through to a merge request you review
- Open source (MIT), one-command Docker setup, honest about its edges
What Shire ISN'T
- A cloud SaaS — that's the vision, not today's product
- A noisy alert firehose — its real job is deciding what not to show you
- A multi-LLM abstraction — it's Claude-only, on purpose
- An agent that touches your code unprompted — implementation is opt-in and lands as a reviewable MR
- A replacement for engineering judgment — you decide, it does the noticing
Open source · MIT
Star it. Fork it. Send a hobit.
Shire is built in the open. If this resonated, the best next step is one click away.
Star it
The fastest way to help. A star tells the next engineer this is worth a look.
Fork & run it
Clone, ./setup.sh, point it at your repos. See the value on your own code in minutes.
Send a hobit
Author a new hobit, file an issue, or open a PR. The roster is a folder of prompts.
$ git clone https://github.com/dardanxh/shire.gitFAQ
Questions, answered
A local-first, Claude-powered engineering companion: specialist agents (hobits) that watch your codebases, run analyses, and surface only what matters.
Tech leads, chief and principal engineers, CTOs and VPs who own many codebases at once and want continuous visibility without alert fatigue.
A React UI talks to a FastAPI backend on PostgreSQL + pgvector. Deterministic scanners run continuously; an engine worker runs the Claude Code CLI headless to reason over what changed. Every Claude call is a tracked job with token and cost accounting.
Yes. Your repos and data stay on your machine, and the API is meant for localhost or a trusted network. Claude is the only external call, and it sees only what changed.
Yes. Rate any answer with a thumbs, score or note; it becomes a lesson the hobit folds into its next runs on its own. Lessons are plain text you can read and edit, and each hobit's autonomy level is a setting you control.
Only when you ask. Click “Implement with AI” on a roadmap ticket and Shire drives the work through to a merge request you review. It never touches your code unprompted.
Clone the repo and run ./setup.sh. Docker brings up the UI on localhost:3000 and the API on :8000; a native dev path is documented too. You'll need a Claude subscription token or an API key.
Honestly: it's young. It started as a prototype, shipped real value fast, and is now MIT-licensed and moving quickly. Expect rough edges; contributions are welcome.
The vision · looking ahead
Where this is heading: a hosted Shire with real-time investigations.
Today Shire runs on your machine. Tomorrow, the same idea becomes a hosted service: hobits that react to events as they land and bring you the finding, not the firehose.
Real-time investigations
Hobits that respond to a risky merge, a spiking hotspot or a fresh CVE, and investigate before you ask.
Hosted Shire
The same local-first engine, run as a managed service for teams that don't want to host it.
Across your whole org
Shared intelligence and councils across teams, so context travels with the work.
Not available yet · the open-source project comes first
Ready to send the hobits?
Clone it, point it at your repos, and see what it finds. If you like what you see, a star helps the next engineer find it.