npm install -g tasuki

Real multi-agent orchestration.
Not just prompt-switching.

In Claude Code, each agent is a real teammate — its own context window, its own model — via Agent Teams. In other AI tools, Tasuki provides structured role-switching that still enforces discipline. 9 hooks, 2-layer memory, a sequential pipeline. Tasuki (襟) — the sash used in Japan to tie back sleeves before working. Say "tasuki" and the pipeline activates.

Get started — it's free See the pipeline
npm
npm install -g tasuki
homebrew
brew tap ForeroAlexander/tasuki && brew install tasuki
9 mechanical hooks Agent Teams 2-layer memory MIT License $0 to onboard
Claude Code — your-project
$ tasuki onboard . ✓ FastAPI + PostgreSQL + React detected ✓ 9 agents configured · 9 hooks installed · Agent Teams enabled Ready. Talk to Claude Code normally.   You: tasuki Add user authentication with JWT   [Planner] → PRD designed · "Continue?" ✓ [QA] → 14 failing tests written (TDD) [DB Arch] → Migration: users, sessions, tokens [Backend] → JWT auth — 14/14 pass ✓ [Frontend] → Login/signup UI · all states [Security] → OWASP audit — PASS ✓ [Reviewer] → Code review — APPROVE ✓   ✓ Feature complete · $1.24 in API credits

See it in action

From onboard to feature — in one prompt.

Process — 9 specialist agents

Real teammates,
not prompt personas.

In Claude Code, each agent runs as an Agent Team member — a real subprocess with its own context window and model. In other tools, Tasuki provides guided role-switching with structured handoffs. Either way: planner first, tests before code, security audit, code review. No shortcuts. See the full pipeline →

Planner
Stage 1
Designs architecture, writes PRDs, decomposes work into per-agent tasks. Waits for your confirmation before any code is written.
thinking · opus
QA
Stage 2
Writes failing tests before any code exists. The test IS the specification. The tdd-guard hook mechanically blocks implementation without tests.
execution · sonnet
DB Architect
Stage 3
Zero-downtime migrations in your exact format. Verifies the plan matches QA's tests before touching the schema.
execution · sonnet
Backend Dev
Stage 4
Runs failing tests first, then implements until all pass. APIs, services, background jobs. Structured handoff to Frontend.
execution · sonnet
Frontend Dev
Stage 5
Shows a design preview for your approval before building. Accessible, responsive UI with all states covered. Figma or generated.
execution · sonnet
Debugger
Stage 5.5
Reactive — only activates when tests fail. Max 5 diagnostic steps, then escalates. Never restarts from zero after a failed fix.
execution · sonnet
Security
Stage 6
Full OWASP Top 10:2025 audit. Variant analysis — finds one vuln, searches the entire codebase. Always runs. No excuses.
thinking · opus
Reviewer
Stage 7
Reads every changed file end-to-end. Cross-references models ↔ routes ↔ schemas ↔ tests. 3-round fix loop. Always runs.
thinking · opus
DevOps
Stage 8
Updates Docker, CI/CD, deploys, runs health checks via Sentry. Only activates when there are infrastructure changes to make.
execution · sonnet
How it works

Sequential by design,
not by accident.

Say "tasuki" in your prompt and the pipeline-trigger hook activates the full process. 9 hooks enforce discipline mechanically — no advisory rules, no hoping the AI behaves. In Claude Code, this is real orchestration via Agent Teams. Every stage has a reason to go exactly where it does. Deep dive →

1
Planner
Confirms with you
Reads your project context, designs architecture, saves the PRD to tasuki-plans/. Decomposes into per-agent tasks via shared task list. Shows you the summary and waits before any code is written.
2
QA — tests first
TDD enforced
Writes failing tests before any implementation exists. The test is the specification. The tdd-guard hook mechanically blocks implementation code if no test file exists — exit code 2, no bypass.
3
DB Architect
Verifies the plan matches QA's tests before creating anything. Migration + model in production-safe DDL patterns: expand-contract for renames, batched defaults for large tables.
4
Backend Dev
Runs the failing tests first to confirm they fail for the right reason. Implements until all tests pass. Produces a structured handoff with every new endpoint, auth behavior, and env var needed by Frontend.
⚡ test checkpoint
all pass → continue · any fail → debugger
5
Frontend Dev
Design preview
Asks if you have a Figma file or want a generated preview before building. Builds responsive, accessible UI consuming verified backend endpoints. All states covered.
⚡ test checkpoint
all pass → security · any fail → debugger
6
Security
Always runs
OWASP Top 10:2025 full checklist, automated Semgrep scan, and variant analysis. Finds one vulnerability, searches the entire codebase for the same root cause pattern.
7
Reviewer
Always runs
Reads every changed file end-to-end, not just the diff. Cross-references models ↔ routes ↔ schemas ↔ tests. 3-round fix loop with regression detection after every change.
8–9
DevOps + Completion
Deploys if needed, health checks via Sentry, then writes a clean summary. Lessons learned save to the knowledge graph — the next task starts smarter.
Works with 8 AI tools

Built for Claude Code.
Compatible with the rest.

One onboard generates config for every tool. Claude Code gets full mechanical automation. Every other tool gets structured role-switching — still dramatically better than nothing.

Claude Code
Full pipeline
Pipeline execution
Agent Teams — real teammates with separate context windows
TDD hook
Mechanical block (exit 2)
Security hook
Mechanical block
Agent isolation
Real — each agent is a subprocess with its own context
Model per agent
Yes — Opus for thinking, Sonnet for execution
Inter-agent messaging
Native (TeammateIdle, TaskCompleted hooks)
Memory vault
Full knowledge graph
Cursor · Codex · Copilot
+ Windsurf, Continue, Roo Code, Gemini
Compatible
Pipeline execution
Role-switching (guided)
TDD hook
Advisory rules
Security hook
Advisory rules
Agent isolation
Same context
Memory vault
Full knowledge graph
Memory — two layers

Memory that persists
across sessions.

Layer 1: wikilinks — $0, offline, human-readable. Layer 2: RAG deep memory — on-demand for deep context. Two layers that get smarter with every task. No server, no embeddings pipeline, no infra. Full architecture →

Traditional RAG
Code → Chunking → Embeddings
→ Vector DB → Semantic search
→ LLM query → $$ per query

Needs: server, API keys, infra
Visibility: black box
Tasuki Memory
Code → Agent learns → writes .md
→ [[wikilinks]] connect knowledge
→ next run → reads only its memories

Layer 1: $0, offline, human-readable
Layer 2: on-demand, local SQLite
Layer 1 — Wikilinks
Each agent reads only its own memories via [[links]]. Backend Dev reads 18 memories → ~72 tokens. Zero extra cost.

Max 20 per agent · 4-dimension format · opens in Obsidian
Layer 2 — Deep Memory
Vector search over schema, APIs, plans, git history. Agent queries: "how do we handle auth?" → full models, endpoints, past PRDs.

Local SQLite · auto-syncs · 50+ entries · <50ms queries
Memory comparison

Claude remembers.
Tasuki's agents learn.

Claude Memory
claude.ai
Scope
General — one pool for everything
Learning
Manual — you tell it or it decides
Loading
All memories loaded every time
Confidence
None — no decay, no scoring
Connections
Isolated entries, no relations
Visibility
Hidden — you can't easily browse or edit
Tasuki Memory Vault
Per-agent memory
Scope
Per-agent — each specialist has its own memories
Learning
Automatic — agents write what they learned after every task
Loading
Filtered — [[wikilinks]] load only relevant entries (~72 tokens)
Confidence
Scored — high/experimental/deprecated + auto-decay + applied-count
Connections
Knowledge graph — BFS traversal across related nodes
Visibility
Open — tasuki dashboard or any editor (plain markdown, git-versioned)

Claude Memory is great for personal preferences.
Tasuki Memory Vault is for agents that get smarter about your project with every task.

Cost

Tasuki is free.
You pay for API credits.

The CLI is MIT open source. Onboarding is bash — $0, zero API calls. The only cost is your normal AI usage, made more efficient.

Fast fix
Small bugs, quick tweaks. Complexity 1–3.
~$0.26
~$0.15 – $0.50 per task
  • 3 agents (Planner, Dev, Reviewer)
  • ~18K tokens
  • Tests + security still run
  • Skips unused stages
tasuki mode fast
Standard feature
New endpoints, components, integrations. Complexity 5–6.
~$0.68
~$0.50 – $1.50 per task
  • 6 agents, full pipeline
  • ~46K tokens
  • TDD + OWASP audit
  • 3-round review loop
tasuki mode standard
Full feature
Complex features, auth systems. Complexity 8–10.
~$1–3
varies with retries & fix rounds
  • All 9 agents
  • ~71K tokens baseline
  • Debugger rounds if needed
  • Full variant analysis
tasuki mode serious

$50 in API credits ≈ 50–80 tasks ≈ roughly one month of active development.
~60% savings from model tiering · ~86% from filtered memory loading · ~40% from agent routing

FAQ

Common questions

Just say "tasuki" in your prompt and the pipeline activates. The pipeline-trigger hook detects the keyword and starts the full process. Everything else — memory loading, hooks, stage tracking — is automatic.
Runs 5 bash detectors against your actual files — no API calls, zero tokens, $0. Detects stack from real imports, versions from package files, paths from directory structure. Generates .tasuki/ with 9 configured agents, 9 hooks, verified project facts, and an initialized knowledge graph. Takes about 10 seconds.
Yes, for Claude Code. Stages 1–9 run automatically via Agent Teams — each agent runs as a real teammate with its own context window. Tasuki activates Agent Teams automatically during onboard. It stops twice for your input: after the Planner shows you the plan and before Frontend starts building. Everything else is automatic. On Cursor and other tools, the pipeline is structured role-switching — the AI follows instructions in order, but you guide transitions between stages.
That's fine — the QA agent writes the tests first for new features. The tdd-guard hook only blocks edits to implementation files when no corresponding test file exists — it won't break your existing codebase.
No. Tasuki is a CLI tool that runs entirely locally — it generates config files. Your code goes wherever your existing AI tool sends it, same as before. Tasuki adds zero new data flows.
13 profiles auto-detected: FastAPI, Django, Flask, Next.js, SvelteKit, Nuxt, Express, NestJS, Rails, Gin, Spring Boot, Laravel, and Generic fallback. If your stack isn't listed, Generic still configures all 9 agents — it just won't have stack-specific migration patterns.
Agent Teams is Claude Code's experimental feature for real multi-agent orchestration. Each agent runs as a subprocess with its own context window and model, not just a prompt persona. Tasuki activates it automatically during onboard. To opt out, set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=0.
Yes. Run brew tap ForeroAlexander/tasuki && brew install tasuki. Works on macOS and Linux.

Real orchestration. Persistent memory.
A process your AI
can't skip.

Free, open source, runs locally. No account needed.

npm
npm install -g tasuki
homebrew
brew tap ForeroAlexander/tasuki && brew install tasuki
click to copy
View on GitHub Read the docs