agentic-patterns
/agentic-patterns
This skill should be used when the user asks about "agentic design patterns", "multi-agent orchestration patterns", "routing/planning/reflection patterns", "the blackboard pattern", "coordinator-of-coordinators", or "saga/circuit-breaker for agents", or needs to apply agentic design patterns to Jira workflow orchestration and the 82-agent hierarchy.
- Author
- TheLobbi ↗
- Repository
- claude ↗
- Licence
- MIT
- Last repository change
- 22.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
This skill should be used when the user asks about "agentic design patterns", "multi-agent orchestration patterns", "routing/planning/reflection patterns", "the blackboard pattern", "coordinator-of-coordinators", or "saga/circuit-breaker for agents", or needs to apply agentic design patterns to Jira workflow orchestration and the 82-agent hierarchy.
Triggers from the description
Original author description
This skill should be used when the user asks about "agentic design patterns", "multi-agent orchestration patterns", "routing/planning/reflection patterns", "the blackboard pattern", "coordinator-of-coordinators", or "saga/circuit-breaker for agents", or needs to apply agentic design patterns to Jira workflow orchestration and the 82-agent hierarchy.
How it works
- Applied Patterns
- Pattern Interaction Map
- Quick Reference: Pattern → Command Mapping
- Coordination Surface (current Claude Code Agent tool)
- References
SKILL.md preview
---
name: agentic-patterns
description: This skill should be used when the user asks about "agentic design patterns", "multi-agent orchestration patterns", "routing/planning/reflection patterns", "the blackboard pattern", "coordinator-of-coordinators", or "saga/circuit-breaker for agents", or needs to apply agentic design patterns to Jira workflow orchestration and the 82-agent hierarchy.
version: 1.0.0
categories: ["agentic-patterns", "orchestration", "multi-agent", "architecture"]
---
# Agentic Design Patterns — Jira Orchestrator
> Patterns from "Agentic Design Patterns" (Gulli & Sauco, 2025) applied to enterprise Jira workflow orchestration, 82-agent hierarchy management, sprint planning, and issue lifecycle automation.
## Applied Patterns
### 1. Routing
**Relevance**: With 46 commands, 16 teams, and 81 agents, every incoming Jira request must be classified and routed to the correct agent team without human disambiguation.
**Current Implementation**: `/jira:triage` classifies issues by type (bug/feature/epic/task), complexity, and domain to determine the optimal workflow path. The `/model` command routes to haiku/sonnet/opus based on task complexity.
**Enhancement**: Formalize intent extraction as a structured routing schema: `{ issueType, complexity, domain, urgency, assignedTeam, estimatedAgents }`. Run routing before any Jira operation to log routing decisions alongside issue history for analytics.
### 2. Planning
**Relevance**: Sprint planning, epic decomposition, and issue breakdown require hierarchical planning that mirrors Jira's own hierarchy (Epic → Story → Subtask).
**Current Implementation**: `/jira:prepare` decomposes issues into subtasks with enriched acceptance criteria. `/jira:sprint-plan` generates capacity-aware sprint plans. `/jira:release` coordinates multi-project release planning.
**Enhancement**: Adopt ReAct-style planning with explicit Thought → Action → Observation cycles logged to Temporal workflow state. Each planning decision references the Jira issue it modifies, creating a full audit trail.
### 3. Multi-Agent
**Relevance**: The 82-agent hierarchy — organized into 16 specialized teams — is the core architectural pattern. No single agent has sufficient context or authority to handle complex enterprise workflows alone.
**Current Implementation**: Teams include Code Team (6 agents), QA Team (6 agents), Security Team (4 agents), DevOps Team (5 agents), Analytics Team (4 agents), and 11 additional specialized teams. Each team has a coordinator agent.
**Enhancement**: Implement a Coordinator-of-Coordinators (CoC) pattern where team coordinators report status to a central orchestrator via the blackboard. The CoC resolves cross-team conflicts (e.g., QA blocking DevOps deploy) and escalates to HITL when consensus is not reached.
### 4. Memory Management
**Relevance**: Jira projects accumulate months of context — sprint history, team velocity, recurring bugs, architectural decisions — that must be retrievable across sessions.
**Current Implementation**: Neon PostgreSQL stores persistent state; Redis caches active session data; knowledge-graph skill maps issue relationships. `/cc-memory` provides three-tier memory for Claude sessions.
**Enhancement**: Implement a Jira-aware memory layer that indexes issue history by project key, team, epic, and recurring pattern type. When starting a new sprint, the memory agent surfaces: velocity trends, unresolved blockers from previous sprints, and recurring defect categories.
### 5. Reflection
**Relevance**: Code review loops, sprint retrospectives, and quality gate checks all require iterative improvement through structured self-critique.
**Current Implementation**: `/jira:review` applies multi-agent code review with security, performance, and quality dimensions. `/retro` facilitates retrospective analysis. The `cc-council` pattern provides multi-perspective reflection.
**Enhancement**: Add a Reflector agent to the Code Team that receives every PR diff and produces structured feedback: `{ correctness: score, security: score, style: score, critique: string[], suggestedRevisions: string[] }`. Failed reviews automatically create child Jira issues with the critique embedded.
### 6. Parallelization
**Relevance**: Sub-issues within a sprint can be executed in parallel by independent agent teams. Sequential execution wastes velocity.
**Current Implementation**: `/jira:work` orchestrates parallel sub-issue execution across agent teams. Temporal workflows manage parallel branch coordination with join synchronization.
**Enhancement**: Implement a dependency graph extractor that reads Jira issue links (blocks/is-blocked-by) and fans out only independent issues. Blocked issues wait in a dependency queue rather than failing or stalling the orchestration.
### 7. Exception Handling
**Relevance**: Jira workflows involve external systems (Harness CI/CD, Atlassian APIs, Neon DB, Redis) — all of which can fail. Robust orchestration must recover without losing work.
**Current Implementation**: Temporal workflows provide durable execution with automatic retry for transient failures. `/jira:cancel` saves checkpoint state. The self-healing protocol captures tool failures to lessons-learned.
**Enhancement**: Build a typed ExceptionClassifier that categorizes failures: `{ type: 'api-timeout'|'auth-expired'|'conflict'|'validation', severity, recoveryStrategy }`. Each failure type maps to a specific recovery playbook: retry with backoff, refresh OAuth token, resolve conflict with HITL, or escalate to team coordinator.
### 8. Human-in-the-Loop (HITL)
**Relevance**: Production deployments, release approvals, SLA escalations, and destructive Jira operations (bulk delete, board reset) require human sign-off.
**Current Implementation**: `/jira:approve` manages approval workflows for PRs, deploys, and releases. Enterprise notification system routes approvals to Slack/Teams/email. SLA escalation paths include human escalation.
**Enhancement**: Serialize agent state at every HITL checkpoint — the full context of what has been done, what is proposed next, and why. Present a human-readable summary with explicit approve/reject/modify options. On resume, inject the human's decision as a typed directive into the agent context.
### 9. Evaluation and Monitoring
**Relevance**: Agent trajectory quality, sprint velocity, SLA compliance, and code review effectiveness all need continuous measurement to drive improvement.
**Current Implementation**: `/jira:metrics` generates real-time dashboards with SLA tracking. `/jira:quality` produces tech debt analysis. Session analytics track agent cost and token spend. Agent trajectory analysis is referenced in orchestration docs.
**Enhancement**: Implement an Evaluator agent that scores each agent action in an orchestration run: `{ agentId, action, relevance, correctness, efficiency, score }`. Aggregate scores per sprint to identify underperforming agents and trigger retraining or prompt revision.
### 10. Prioritization
**Relevance**: Backlog ordering, sprint candidate selection, and in-sprint issue sequencing all require principled prioritization that balances urgency, value, and effort.
**Current Implementation**: `/backlog-groom` applies prioritization logic. `/jira:sprint-plan` uses capacity-aware scoring. `/jira:intelligence` provides AI-powered predictive prioritization.
**Enhancement**: Formalize a Priority Score agent that computes `(business_value × urgency) ÷ (effort × risk)` for each issue using Jira field data. Re-score the entire backlog after each sprint close, incorporating velocity actuals and changed business context.
### 11. Goal Setting
**Relevance**: Sprint goals, release targets, and SLA objectives give agent teams a measurable north star. Without explicit goals, agents optimize locally at the expense of team outcomes.
**Current Implementation**: Sprint goals are referenced in `/jira:sprint` and `/jira:release`. SLA targets drive `/jira:sla` monitoring. Portfolio objectives are tracked in `/jira:portfolio`.
**Enhancement**: Formalize a Goal object at sprint start: `{ sprintGoal: string, successCriteria: string[], keyMetrics: { velocity, defectRate, slaCompliance }, deadline: date }`. The Evaluator checks goal progress after each daily sync and surfaces blockers to the Coordinator.
## Pattern Interaction Map
```
Incoming Jira Request
│
▼
[Routing] ──────────────────────────────────┐
│ │
▼ ▼
[Goal Setting] ←── [Prioritization] [Memory Management]
│ │
▼ │
[Planning] ──────────────────────────────────┤
│ │
▼ │
[Parallelization] ──→ [Multi-Agent (81 agents)]│
│ │ │
│ [A2A via Blackboard] │
│ │ │
▼ ▼ │
[Exception Handling] [Reflection] ←──────────┘
│ │
▼ ▼
[HITL] ←── [Evaluation & Monitoring]
│ │
└──────────────────────┘
│
[Feedback Loop]
(Retrospective → Backlog)
```
### Key Synergies
- **Routing + Prioritization**: Route only after priority is established so the highest-value work reaches agents first
- **Multi-Agent + Exception Handling**: Team coordinators handle intra-team exceptions; CoC handles cross-team conflicts
- **Memory + Planning**: Historical velocity and defect data inform sprint capacity planning
- **Reflection + Goal Setting**: Retrospective reflection updates next sprint's goal criteria
- **Parallelization + Evaluation**: Score parallel branches independently so the best approach wins
## Quick Reference: Pattern → Command Mapping
| Pattern | Primary Command | Jira Entity |
|---------|-----------------|-------------|
| Routing | `/jira:triage` | Issue classification |
| Planning | `/jira:prepare`, `/jira:sprint-plan` | Epic/Story/Subtask |
| Multi-Agent | `/jira:work`, `/jira:orchestrate-advanced` | 81-agent teams |
| Memory | `/jira:setup` (Neon/Redis) | Cross-session state |
| Reflection | `/jira:review`, `/retro` | PR review, retrospective |
| Parallelization | `/jira:work` | Sub-issue fan-out |
| Exception Handling | `/jira:cancel` + Temporal | Workflow recovery |
| HITL | `/jira:approve` | Deploy/release approval |
| Evaluation | `/jira:metrics`, `/jira:quality` | Sprint/agent scoring |
| Prioritization | `/backlog-groom`, `/jira:intelligence` | Backlog ordering |
| Goal Setting | `/jira:sprint`, `/jira:release` | Sprint/release goals |
## Coordination Surface (current Claude Code Agent tool)
Implementing these patterns today maps onto the runtime's native primitives:
| Need | How |
|---|---|
| Spawn a specialist | `Agent` tool (the tool formerly named `Task`) with `subagent_type`, `model` (`fable`/`opus`/`sonnet`/`haiku` aliases), and a focused prompt |
| Run teams concurrently | Issue independent spawns in one message; `run_in_background: true` for non-blocking workers |
| Continue a teammate with its context intact | Give it a `name` at spawn, then `SendMessage` to that name — a fresh `Agent` call starts a new context |
| Prevent file contention between parallel coders | `isolation: "worktree"` (auto-cleaned if unchanged) |
| Force plan-first behavior | `mode: "plan"` on the spawn |
| Long-horizon coordinator (multi-hour epics, overnight runs) | Put the coordinator on `model: fable` — Fable 5 sustains long-lived async sub-agent fleets without drift; keep workers on Sonnet |
Only a teammate's **final message** returns to the coordinator — require workers to end with a structured summary (blackboard writes happen via files, not transcripts).
## References
- Gulli, A. & Sauco, M. (2025). *Agentic Design Patterns*. O'Reilly Media.
- Repository: github.com/Mathews-Tom/Agentic-Design-Patterns
- Atlassian Jira REST API: developer.atlassian.com/cloud/jira/platform/rest/v3/
- Temporal Workflow Docs: docs.temporal.io
- Related Skills: `skills/structured-reasoning/SKILL.md`, `skills/sprint-intelligence/SKILL.md`
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · TheLobbi/claude | 95 | MIT |
| andreibesleaga/gabbe | 90 | CC-BY-4.0 |
| rsmdt/the-startup | 90 | MIT |
Database snapshot: 13.11.2026 · package version c6c424acc2c2 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100cc-agentic-patterns
Select and wire an agentic design pattern (reflection, prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer, ReAct, blackboard) into the 5-layer Claude Code stack. Use this skill whenever deciding how to structure a multi-step task, whether to… - 95agentic-orchestration
Patterns for multi-agent coordination, task decomposition, handoffs, and workflow orchestration. Best practices for building and managing agent systems. Use when designing how multiple agents coordinate — splitting up tasks, defining handoffs, or choosing an orchestration topology. - 100orchestration-patterns
Agentic orchestration patterns for long-running tasks. Implements evidence-based delivery and iterative agent loops. Use when managing multi-step work, coordinating workflows, or orchestrating PR workflows. - 95agentic
AI/LLM engineering patterns. Triggers when building agents, prompts, MCP servers, evals, or RAG. Model selection, caching, tool design, multi-agent orchestration. - 100mcp-circuit-breaker
Detects MCP tool failure patterns and trips a circuit breaker to stop cascading retries. Proposes fallback alternatives and resets when the tool recovers. Triggers on "MCP failing", "tool keeps erroring", "circuit-breaker", repeated tool call failures. - 95wicked-garden-agentic-architect
Five-layer architecture validation, agent topology analysis, orchestration pattern assessment, and framework detection for agentic systems. Use when: architecture review of an AI agent system, agent topology analysis, validating the five-layer model…