agent-hub

✨ The idea

You don't want a different assistant per project. You want one great team that knows
which project it's in.

Open Claude Code in a backend repo → the team thinks in your backend stack.
Open it in a web repo → the same team thinks in your frontend stack.
Same roster. Different brain. Zero manual switching.

The magic is a tiny per-project file the whole team reads before acting. Claude Code
auto-loads it when you open the project — so specialization is automatic.

~/my-service  ❯ "add rate limiting to the login endpoint"
   tech-lead reads .claude/agent-hub/profile.yml  → your stack · framework · pkg manager
   ├─ architect    designs the guard + token-bucket store
   ├─ backend-eng  implements it in your framework
   ├─ security     checks auth bypass & lockout edge cases
   └─ code-review  signs off

🎬 See it

🚀 Install

/plugin marketplace add berkcangumusisik/agent-hub
/plugin install super-team@agent-hub

That's it — the team is now available in every project on your machine.

🧭 Use it in a project

From inside any project directory:

/onboard      # detects your stack, scaffolds the project profile

This writes .claude/agent-hub/profile.yml + .claude/CLAUDE.md. Review the detected
values, fix anything wrong, and you're done. From then on, just describe what you want —
tech-lead routes the work to the right specialists.

/team         # show the roster and who's active for this project
/review       # full team review of your diff (correctness + security + tests + design)
/decide       # record an architectural decision to the team's memory (ADR)
/handoff      # summarize where we are for the next session

When you open Claude Code in a project that has a profile, a SessionStart hook
auto-loads it — so the team is oriented to your stack before you type a word.

🧠 How it works

Two layers:

1. The super-team (this repo, a Claude Code plugin) — a roster of specialist
   subagents. Installed once, present everywhere.
2. The project profile (per project) — a .claude/agent-hub/profile.yml +
   CLAUDE.md describing the project's stack, commands, and conventions.

Every agent runs a Profile-first protocol: read the profile before doing anything, then
act in that project's idioms. Because Claude Code auto-loads a project's CLAUDE.md when
you open it there, switching projects switches the team's behavior — automatically.

👥 The roster

Models are tuned per role for a quality/cost balance — override any of them in the agent's
frontmatter.

📄 The profile

.claude/agent-hub/profile.yml is the single source of truth a project hands the team:

project:
  name: my-service
  type: backend
stack:
  language: TypeScript
  framework: NestJS
  database: PostgreSQL
  packageManager: pnpm
commands:
  install: pnpm install
  test: pnpm test
team:
  active: [tech-lead, architect, backend-engineer, code-reviewer, security-reviewer]
conventions:
  - Use the repository pattern for data access
doNot:
  - Never expose entities directly in API responses

A starter template lives in templates/project-profile/ —
or just run /onboard and let the team fill it from your codebase.

🗂 Repo layout

agent-hub/
├── .claude-plugin/marketplace.json     # marketplace manifest
├── plugins/super-team/                 # the plugin
│   ├── .claude-plugin/plugin.json
│   ├── agents/                         # the 12 specialists
│   ├── skills/                         # agent-hub-init, load-profile, handoff, decision-log
│   ├── commands/                       # /onboard, /team, /review, /decide, /handoff
│   └── hooks/                          # SessionStart: auto-load the project profile
├── templates/project-profile/          # per-project .claude/ starter
├── templates/profiles/                 # ready profiles (Spring, Django, Next, Flutter, Go, Expo)
├── site/                               # marketing site (Vite + React + Tailwind)
└── scripts/validate.mjs                # zero-dep CI validation

❓ FAQ

No. /onboard inspects your repo (package.json, pom.xml, pubspec.yaml, CI config…)
and fills the profile for you. You just confirm.

Plain subagents are global and stack-agnostic. agent-hub makes one team project-aware:
the same roster reads each project's profile and adapts, so you don't maintain a separate
set of agents per repo.

Yes — per project via team.active in the profile, or globally by editing the roster.
See CONTRIBUTING to add a new specialist.

It's stack-agnostic — the agents derive everything from your profile. Node, Java, Python,
Dart, Go… if Claude Code can read it, the team can work in it.

🛣 Roadmap

• /handoff command to summarize state for the next session
• data-engineer and ux-designer specialists
• Starter templates for popular stacks (Spring Boot, Django, Next, Flutter, Go, Expo)
• /review orchestrated multi-agent review
• Team memory — decision log (/decide + ADRs)
• SessionStart hook that auto-loads the project profile
• Profile linting in /onboard
• Per-package profiles for monorepos

Have an idea? Open an issue or a PR.

🤝 Contributing

PRs of every size are welcome — a sharper agent prompt, a new specialist, an example
profile. Run node scripts/validate.mjs before pushing. See CONTRIBUTING.md.

⭐ Like it?

If agent-hub saves you time, star the repo — it helps others find it and motivates the
roadmap.

📝 License

MIT © Berkcan Gümüşışık