aiset

The shared brain for your AI coding team

Turn your repositories into a team of Claude Code agents that remember what they learn,
work in parallel, and show you every step, live.

Quick start  ·  Tour  ·  Commands  ·  User guide  ·  Research

_{The Office, live: the PM waits on two engineers fixing bugs in parallel. Real recording, sped up 1.5×.}

Quick start

pipx install aiset-cli                             # or: pip install aiset-cli
aiset-init ~/work/shop --team shop                 # scan the repos, generate the team
shop-pm                                            # talk to your PM, from any folder

Then open the office in a second terminal with aiset and visit http://127.0.0.1:8765.

Give the PM its first task:

"Build the knowledge briefs. Document the architecture, conventions, test commands and known pitfalls for each repository."

_{Needs Python 3.9+, Git and Claude Code. TypeScript indexing also uses Node.js. Works with a folder of repositories or a monorepo. The PyPI package is aiset-cli (aiset on PyPI is an unrelated project). To hack on aiset itself, clone it and pip install -e ..}

Why aiset

Coding agents start every session from zero. They re-read the same files, rediscover the same conventions and repeat the same investigations, and you can't see what they're doing until they're done.

A real run, start to finish

Every frame below comes from Beanboard, a small demo app: three FastAPI services (catalog on PostgreSQL, reviews on MongoDB, insights calling both) and a React UI on Docker Compose. One aiset-init turned it into a team of seven. Nothing is staged, and you can run the same demo yourself in about five minutes.

1  Ask in plain words

You describe a feature. The PM pins down scope before anyone writes code.

2  The team works in parallel

The PM writes a task board and hands each engineer an assignment with the contract to follow. You watch status, model and cost per task, then open a task to see every file each agent read and edited.

3  Follow every read and edit

The Brain draws live trails from each agent to the briefs, files and services it touches.

4  Get a verified report

Findings come back ranked, with file and line references, proposed fixes and effort. The full handoffs stay in the workspace.

5  The knowledge compounds

After two tasks the Brain connects 7 agents, 4 repositories, 5 briefs with 56 sections and 2 episodes to the code's 13 endpoints, 8 models and 10 frontend API calls. The next task starts there, not from zero.

6  Architecture, read from the code

Services, databases and the calls between them, each backed by a file and line. Solid links are exact; dashed links are inferred from names.

What's inside

Commands

$ teammap impact "/api/catalog/beans/{bean_id}" PATCH
impact · endpoint PATCH /api/catalog/beans/{bean_id}
  PATCH /api/catalog/beans/{bean_id} is handled by update_bean() in catalog-service/app/routes.py:37
  4 consumer(s) found (1 exact), 2 model(s), 2 test file(s)
models (2)
  = catalog-service/app/schemas.py:18  BeanUpdate  6 fields
      request parameter payload: BeanUpdate
  = catalog-service/app/schemas.py:27  Bean  8 fields
      response_model Bean
consumers (4)
  = ui/src/api.ts:50  updateBean  PATCH /api/catalog/beans/{}
      HTTP call to the same URL
  ~ ui/src/pages/BeanDetailPage.tsx:40  BeanDetailPage.savePrice
      calls updateBean() (matched by name)
  …

How it works

your-project/
├── catalog-service/ · reviews-service/ · ui/ …   your code, untouched
└── .claude/
    ├── agents/          PM, engineers, QA, integration checker (Claude Code loads these)
    └── team/
        ├── roster.json  who owns which repo, and on which model
        ├── knowledge/   briefs: architecture, conventions, pitfalls, dated field notes
        ├── tasks/       boards, contracts, handoffs
        ├── episodes/    what each finished task decided and learned
        └── graph/       code index, Brain graph, stored research results

Engineers read their brief's index and only the sections they need. When a task closes, the PM writes an episode and carries the lessons into the owner's brief, which is how the next task starts ahead.

Everything is plain Markdown and JSON in your workspace. In a monorepo, .claude/ is kept out of git by default; pass --share to version it with the team.

Privacy

• Local only. The dashboard binds to 127.0.0.1 and checks Host and Origin headers. It's not built for public hosting.
• No new data flows. aiset reads the transcripts Claude Code already writes. Model calls go through your own Claude Code setup, nothing else.
• No secrets read. The architecture scan reads env var names only, and never opens .env files or secrets/ folders.
• Zero runtime dependencies. Python standard library only.

FAQ

Contributing

Issues and pull requests are welcome. Read CONTRIBUTING.md for setup and guidelines (make check runs everything), and report vulnerabilities privately as described in SECURITY.md.

More docs: User guide · Feature inventory · Research tools · Brand assets

_{If aiset saves you time, a ⭐ helps other developers find it.
MIT licensed · Built for Claude Code}