Skip to main content
Back to Blog
announcement

Introducing JARFIS: 11 AI Agents, One Slash Command

announcementarchitectureagents

Introducing JARFIS: 11 AI Agents, One Slash Command

Software development teams spend enormous time coordinating work across disciplines — product, design, engineering, QA, DevOps. Every handoff introduces friction. Every context switch costs time. JARFIS is built on one idea: what if you could eliminate those handoffs entirely?

JARFIS (Just A Rather Foolish Integration System) is a 100% open-source AI agent framework that runs natively inside Claude Code as a slash command workflow. It orchestrates a team of 11 specialized agents that collaborate across every phase of the software development lifecycle — with no external services, no vendor lock-in, and no separate CLI to install.

The Problem with Single-Agent AI

Most AI coding tools today are single agents. You ask a question, you get an answer. You describe a feature, you get code. That model works — up to a point.

The real bottleneck in software delivery is never "can someone write this code." It's the full workflow: understanding requirements, making design decisions, writing code that matches the spec, catching regressions, handling deployment. No single agent can hold all of that context reliably.

JARFIS solves this with specialization. Each agent owns a specific domain and hands off to the next with structured, validated output.

The 11 Agents

JARFIS ships with 11 purpose-built agents, each responsible for a distinct role:

| Agent | Primary Responsibilities | |-------|--------------------------| | Product Owner (PO) | Conducts reverse-questions to clarify requirements, writes Working Backwards press release, authors PRD | | Architect | Evaluates feasibility, performs impact analysis, designs system architecture, writes ADRs | | Tech Lead | Reviews API specifications, breaks down tasks, conducts code reviews, leads retrospective | | UX Designer | Directly produces SVG assets and design token systems; designs screens and interactions (activated only when UI work is required) | | Backend Engineer | Implements backend services, APIs, and data models | | Frontend Engineer | Implements UI components, frontend logic, and integration | | DevOps/SRE | Sets up infrastructure, CI/CD pipelines, and deployment configuration | | QA Engineer | Defines test strategy and executes QA verification | | Security Engineer | Performs pre-review security analysis and security review | | Advocate | Champions proposed changes by analyzing their merits and user value in dialectic reviews | | Critic | Critically examines proposed changes to identify risks, side effects, and design inconsistencies |

These agents don't just run sequentially — they collaborate. The Frontend Engineer implements against the UX Designer's specifications. The QA Engineer tests against the PO's acceptance criteria. The Tech Lead reviews every engineer's output before it ships.

The 9-Phase Pipeline

JARFIS organizes every workflow through 9 defined phases, each with specific inputs, outputs, and responsible agents. Three Human Gates sit at critical checkpoints — no phase after a Gate proceeds without explicit user approval.

Phase T:   Triage               — classify request type
Phase 0:   Pre-flight           — git sync, load learnings
Phase 1:   Discovery            — PO + Architect
           ↓ Gate 1: Approve / Revise / Abort
Phase 2:   Architecture         — system design, task breakdown
Phase 3:   UX Design            — screen & interaction specs (conditional)
           ↓ Gate 2: Approve / Revise / Abort
Phase 4:   Implementation       — parallel BE / FE / DevOps
Phase 4.5: Operational Readiness — deployment & rollback plan
Phase 5:   Review & QA          — parallel Tech Lead / QA / Security reviews
           ↓ Gate 3: Approve / Revise & re-review / Abort
Phase 6:   Retrospective        — learnings accumulated for future workflows

Every Gate produces an artifact — a document, a test report, a signed-off spec — that feeds the next Phase. Nothing proceeds until the Gate clears. This means fewer surprises late in the cycle, and a clear audit trail of every decision.

What This Looks Like in Practice

JARFIS runs as a slash command inside Claude Code. Starting a new feature looks like this:

/jarfis:work Implement user authentication with OAuth 2.0

JARFIS picks up from there:

  1. Phase T classifies the request and determines which agents are needed
  2. Phase 0 syncs Git state and loads project learnings
  3. Phase 1 — the PO clarifies requirements, the Architect evaluates feasibility. You review and approve at Gate 1
  4. Phase 2 — the Architect designs the system, the Tech Lead breaks down tasks
  5. Phase 3 — if UI is involved, the UX Designer creates interaction specs. Gate 2 follows
  6. Phase 4 — Backend Engineer, Frontend Engineer, and DevOps/SRE work in parallel
  7. Phase 4.5 — deployment strategy and rollback plan are prepared
  8. Phase 5 — Tech Lead, QA Engineer, and Security Engineer review in parallel. Gate 3 follows
  9. Phase 6 — learnings are accumulated to improve the next workflow

The result is production-ready code with tests, documentation, and a clean git history — not a prototype.

Claude Code Native, Open Source

JARFIS runs entirely within your Claude Code environment. There is no separate server to run, no external API to call, and no account to create. Install it once with a single command:

bash install.sh

From that point on, JARFIS is available as a slash command in any Claude Code session:

/jarfis:work [description]
/jarfis:meeting [topic]

The meeting command initiates a structured planning session. Meeting decisions can then be referenced in subsequent workflows:

/jarfis:work Implement auth system --meeting auth-strategy-meeting

The framework itself is open source under the AGPL-3.0 license. Every agent prompt, every Gate criterion, and every workflow configuration is inspectable and modifiable. If JARFIS does something you don't like, you can change it.

What's Next

JARFIS v1.0 covers the full development lifecycle for most web application projects. Upcoming work includes:

  • Agent Dashboard: Real-time visibility into what each agent is doing and why
  • Custom Agents: A plugin API for adding domain-specific agents to the pipeline
  • Multi-Repo Orchestration: Coordinate agents across microservice architectures
  • Gate Policies: Configure custom pass/fail criteria per Gate per project

If you're building with JARFIS, we want to hear about it. Open an issue, start a discussion, or submit a PR. The framework gets better when more teams use it on real problems.

Star the repo and join the community. Development starts now.