Not a marketplace you configure. A complete pre-configured team — 25 specialists, a lead orchestrator, 18 enforced workflows, and a Pipeline Auditor that verifies work was done — not just reported.
Without structure, AI assistants cut corners, forget standards, and drift. A Team fixes that.
A fixed sequence from idea to production. No shortcuts. No skipped steps.
Each agent has a single job. Irrelevant specialists are pruned automatically at setup — you only get what your project needs.
Plans the day, dispatches work, manages state. Never writes product code.
Tests first, implements second, debugs root causes before touching code.
Inspect every change before merge. Code quality, security, compliance, audit trail.
Specialist reviewers who know the idioms, patterns, and pitfalls of each stack.
E2E tests, documentation, performance profiling, loop safety, communications.
Not suggestions. Every gate fires automatically. The Pipeline Auditor catches any agent that skips one.
Run the actual command. Read the actual output. "It should work" is not evidence.
Write the failing test first. Then write the code that makes it pass. No exceptions.
No patches without understanding why. Three failed fixes = deeper problem — stop and talk.
Every new feature starts with a brainstorm. No code until the approach is agreed.
Write what the API accepts, returns, and can fail — before writing a single line of code.
Every database change needs a tested undo step. No migration without a way back.
Every diff line traces to the task. No "while I'm here" improvements allowed.
"I think it's faster" is not a result. Numbers or it didn't happen.
Same agents. Same rules. Same standards. Your whole team, whatever tool they use.
Full support — hooks, slash commands, native sub-agent dispatch, worktrees
Full SupportAll agents and skills load via plugin manifest — rules and session hook included
Full SupportSkills and rules loaded via plugin; agents available on demand across projects
Strong SupportAll 10 command aliases available; open-source and self-hostable
Good SupportPick your install method, declare your project scope, run one command.
bash <(curl -fsSL https://raw.githubusercontent.com/RBraga01/a-team/main/install.sh)irm https://raw.githubusercontent.com/RBraga01/a-team/main/install.ps1 | iexInstalls .claude/, skills/, hooks/, and INIT.md into the current directory. Skips files that already exist. No build step, no dependencies.
gh repo clone RBraga01/a-team -- --depth 1
cp -r a-team/.claude a-team/skills a-team/hooks a-team/templates ./
cp a-team/INIT_TEMPLATE.md INIT.md
rm -rf a-teamRequires the GitHub CLI. Shallow clone — only the latest commit.
git clone --filter=blob:none --sparse --depth 1 \
https://github.com/RBraga01/a-team.git
cd a-team
git sparse-checkout set .claude skills hooks templates INIT_TEMPLATE.md
cp -r .claude skills hooks templates ../
cp INIT_TEMPLATE.md ../INIT.md
cd .. && rm -rf a-teamgit clone --filter=blob:none --sparse --depth 1 `
https://github.com/RBraga01/a-team.git
cd a-team
git sparse-checkout set .claude skills hooks templates INIT_TEMPLATE.md
Copy-Item -Recurse .claude,skills,hooks,templates ..\
Copy-Item INIT_TEMPLATE.md ..\INIT.md
cd .. ; Remove-Item a-team -Recurse -ForceSparse checkout — downloads only the required directories, not the full repo history.
.claude/, skills/, hooks/, templates/ into your project rootINIT_TEMPLATE.md to INIT.mdNo git or command line required. Works on any OS.
INIT.md — your project's scopeTick the checkboxes: languages, stack, compliance requirements, AI platforms. Plain markdown. Takes 5 minutes. The orchestrator reads this file once and deletes every agent and skill that doesn't apply to your project.
/orchestrate initThe Lead Orchestrator prunes the team, generates the routing table, and writes the active roster. Every subsequent session starts automatically — no manual setup needed per session.
Everything you need to know before you start.
A Team is a folder you drop into any project. It installs 25 specialist AI agents, 18 enforced workflow skills, and a lead orchestrator that manages a daily task cycle. Every session starts with your coding standards automatically re-injected — standards that can't be bypassed.
Think of it as the difference between one AI assistant trying to do everything and a coordinated engineering team with clear roles, quality gates, and an audit trail.
No. A prompt library gives you text to paste. A Team gives you enforced structure: hooks that fire at every session start, hard gates that block completion unless evidence is produced, an orchestrator that audits whether agents actually ran their checks, and a file-locking system that prevents parallel agents from colliding.
The key word is enforce. An agent that skips a mandatory gate gets flagged and blocked from merging — it's not optional.
About 10 minutes for a new project:
INIT.md — tick checkboxes for your languages and stack (~5 min)/orchestrate init — the team configures itself (~3 min)After that, every session starts automatically. No daily configuration needed.
No. A Team is designed to bring senior-level standards to any developer. The agents enforce TDD, surgical changes, security reviews, and proper root-cause debugging automatically — you don't need to know why each rule exists to benefit from it.
That said, senior developers will recognise the patterns (Clean Architecture, OWASP, TDD) and may want to customise the rules for their specific context.
Yes. The process has four steps:
-n (no-clobber) — copy .claude/, skills/, hooks/, and templates/ into your project root using cp -rn. This skips any files you already have, so your existing .claude/settings.json and agent configs are preserved.INIT.md to describe what already exists — list the languages, frameworks, and modules already in use. Describe the current test coverage and any known technical debt. The orchestrator uses this to prune irrelevant agents; if you don't describe your stack accurately, it may delete agents you need or keep ones you don't./orchestrate init and review the result — check .agent-sync/TEAM.md before continuing. Restore any agent that was pruned incorrectly./orchestrate morning — let the orchestrator read the repo state before you make any changes. Approve the plan, then proceed.What to avoid: don't let A Team overwrite an existing .claude/settings.json without reviewing the merge — you may lose permissions or hooks you already configured. And don't request retroactive TDD across the whole codebase at once; prioritise the areas with the highest change frequency or risk first.
None specifically. A Team is model-agnostic infrastructure — it's markdown files and JSON. It works with any model your chosen platform supports.
Agents are organised into three capability tiers. Use the model that matches the tier on your platform:
| Tier | Claude | OpenAI / Codex | Google / Gemini | Used by |
|---|---|---|---|---|
| Tier 1 | Opus 4.8 | o3 / GPT-5.5 | Gemini 2.5 Pro | Orchestrator, Architect |
| Tier 2 | Sonnet 4.6 | GPT-4.1 | Gemini 2.5 Flash | Most specialist agents |
| Tier 3 | Haiku 4.5 | GPT-4.1-mini | Gemini Flash-Lite | Docs, audit, profiling |
On Claude Code, the model: frontmatter in each agent file sets the default automatically. On Codex, Cursor, and OpenCode, select the equivalent tier in your platform's model settings — the frontmatter is a Claude Code-specific field and may be ignored by other platforms.
Yes. All platforms share the same .agent-sync/ directory (DAILY.md, ROUTING.md, TEAM.md), so orchestrator state is visible regardless of which CLI triggered it.
Important: session-start hooks are not propagated between platforms. Each platform's plugin manifest configures its own onSessionStart hook independently — the files are already pre-configured for Claude Code, Codex, and Cursor.
Yes. A Team is platform-agnostic — it's markdown files and JSON, with no compiled code or OS-specific scripts. The path normalisation for git worktrees uses standard POSIX-style paths that work across all systems via the git CLI.
The bash commands in agent files (for running tests, linting, etc.) are standard shell commands that work on all three platforms.
When multiple agents work in parallel on isolated git worktrees, they can both try to modify the same source file at the same time — even though they're physically in separate directories. Git worktrees prevent physical conflicts, but not logical ones that appear at merge time.
The File Lock Protocol solves this: before dispatching any agent, the orchestrator registers which files it will touch in ROUTING.md. If a second agent tries to claim a file already marked in-progress, it's queued with a depends_on instead of dispatched. All paths are normalised to repo-relative form so worktree-local paths never cause false negatives.
Agents are specialists with a defined role, model, and tool set. They run as sub-agents dispatched by the orchestrator or triggered directly. Each has a single responsibility — debugger investigates root causes, code-reviewer reviews code, planner creates implementation plans.
Skills are enforced workflow instructions. Some are hard gates — the verification-before-completion skill literally blocks any agent from claiming "done" without running a real command and reading the output. Skills are consulted by agents before acting; they cannot be opted out of.
No. The orchestrator prunes automatically at /orchestrate init based on your INIT.md. A small Python API project, for example, ends up with roughly 12–14 active agents after pruning — all the mobile reviewers, the Rust specialist, the chief of staff, and other irrelevant agents are deleted from the workspace.
The team that runs is exactly the team your project needs. Nothing more.
Yes, both:
.md file in .claude/agents/ with the standard frontmatter (name, description, allowedTools, model), add it to .agent-sync/TEAM.md, and register its trigger in skills/using-a-team/SKILL.md./writing-skills meta-skill — it walks you through spec, TDD, and validation of the new skill before adding it to the library. After creation, register the trigger in using-a-team/SKILL.md.The harness-optimizer agent acts as a pipeline auditor before every merge. It reads the bash command history (~/.claude/bash-commands.log) and task result files to verify that:
code-reviewer result exists for every task that modified source filesROUTING.md were released after task completionIf it detects evasion, it writes a BLOCK MERGE verdict to .agent-sync/AUDIT.md. The orchestrator reads this file before dispatching finishing-a-development-branch — if blocked, the failing tasks are routed back for re-execution.
Yes. A Team is released under the MIT License. You can use it, modify it, distribute it, and include it in commercial projects — the only requirement is keeping the copyright notice in any distribution.
Standard GitHub flow:
feat/your-agent-name or fix/descriptionSKILL.md trigger registered, new skills need TDD validation via /writing-skillsThe most valuable contributions are new specialist agents for languages or domains not yet covered, and improvements to the hard gate skills.
Open a GitHub Issue in the repository. Include:
For security-related issues, please use GitHub's private vulnerability reporting rather than a public issue.
A Team is the foundation. Each builder-* pack adds enforcement for a specific domain — all standalone, all sharing the same Completion Statement Format model.
8 skills and 5 agents for AI engineering quality. Eval, prompt versioning, fallback design, RAG pipelines, safety review. Three hard gates that block ship.
8 skills and 5 agents for AI UI design. States, streaming UI, prompt UX, accessibility, and design tokens — the design layer that generic systems don't cover.
6 skills and 3 agents for product quality. PRD gates, feature scoping, metric definition, research synthesis, A/B test design, and AI feature validation before engineering begins.
6 skills and 3 agents for growth quality. Positioning that survives "so what?", copy that passes "who cares?", experiments with pre-specified stopping rules, and AI messaging reviewed for accuracy.
A Team was built by studying, using, and needing to personalise several excellent open-source projects. The architecture combines the best patterns from each into a single, portable baseline.
Skill-based methodology, TDD enforcement, subagent-driven development, and Git Worktree isolation
Logical task-state management using Markdown files and atomic Git commits as the state machine
Concurrent agent coordination and file-level conflict detection across parallel agent workspaces
Headless automated test suite for validating the semantic effectiveness of rules and prompts
Short, density-focused rule files with mandatory [VALID]/[INVALID] examples for LLM pattern replication
Modular skill library architecture with native tool integrations
Token optimisation via hooks that prune redundant command history and debug logs from agent context
Agent identity standardisation through structured files and framework-agnostic state contracts
A Team is free and open source. A GitHub star helps others discover it.
Star A Team on GitHub