Jazzband: A TypeScript Orchestration Layer for Ticket-Driven Agent Workflows

Jazzband Overview Jazzband is a TypeScript-native intelligent agent orchestration framework focused on ticket-driven development workflows, enabling a complete closed loop from Linear tickets to code implementation, code review, and delivery verification.

Basic Info

• Original Author/Maintainer: humanbased-ai
• Source Platform: GitHub
• Repo Link: https://github.com/humanbased-ai/jazzband
• Release/Update Time: 2026-06-07

This thread will cover the project's background, core philosophy, workflow, architecture, CLI commands, roadmap, and practical significance.

In the era of abundant AI-assisted development tools, developers face the problem of integrating various tools into a coherent workflow. Tools for requirement management (Linear, Jira), code generation (GitHub Copilot, Claude), code review (Crosscheck), and delivery verification (VerifyFlow) are excellent but lack smooth connections, relying on manual coordination.

Jazzband addresses this fragmentation. As a TypeScript-native orchestration layer, it focuses on ticket-driven workflows, aiming to connect Linear tickets, GitHub PRs, code reviews, and delivery verification into a publicly inspectable, auto-executable delivery loop.

Core Philosophy: Public handoff over private log scraping. Traditional agent systems rely on private logs for state inference, which is fragile and hard to audit. Jazzband requires all key handoffs via public, inspectable interfaces, bringing benefits like:

• Auditability: Full workflow history visible to anyone
• Debuggability: Easy integration with monitoring and alerts
• Composability: Tools interact via standard interfaces (not tightly coupled)
• Security: Reduced dependency on private state/sensitive logs

Target Workflow: 4-stage delivery loop

1. Ticket Understanding: Parse Linear ticket (requirements, acceptance criteria) to generate a structured implementation plan.
2. Code Implementation: Coordinate AI coding agents (Claude, GPT) to generate code with incremental commits and continuous validation.
3. Code Review: PRs auto-enter Crosscheck for merge readiness assessment (functionality, security, style) with SHA-bound annotations.
4. Delivery Verification: Passed PRs go to VerifyFlow for validation reports and evidence chains to ensure compliance with original ticket requirements.

Jazzband follows 6 core principles:

1. TypeScript First: npm-native package with full type definitions for IDE auto-completion and error checking.
2. Independent & Composable: Can be used as a standalone CLI or library, adapting to individual or enterprise needs.
3. Separation of Config, State, Logs: Each tool maintains its own data; Jazzband uses well-defined interfaces for information transfer (Separation of Concerns).
4. SHA-Bound PR Annotations: Review/validation results are anchored to Git commit SHA, ensuring traceability even if PRs are modified.
5. Dry Run First: Irreversible operations require explicit flags; default is dry run to show actions without execution.
6. Clear Tool Responsibilities:

   Tool	Responsibility
   Jazzband	Orchestration, ticket workflow, agent scheduling
   Crosscheck	Code review & merge readiness assessment
   VerifyFlow	Delivery verification & evidence reporting

Core CLI Commands:

• plan: Generate implementation plan from Linear ticket (e.g., jazzband plan --ticket IN-123 --repo humanbased-ai/monorepo).
• status: Query PR status (review progress, validation results, blockers; e.g., jazzband status --pr https://github.com/humanbased-ai/monorepo/pull/456).
• run: Execute full delivery loop (ticket → PR → review → verification; e.g., jazzband run --ticket IN-123 --repo humanbased-ai/monorepo).

Tool Integration: Jazzband connects existing tools without replacing them:

• Linear/Jira: Requirement/ticket management
• GitHub/GitLab: Code hosting & PRs
• Crosscheck: Intelligent code review
• VerifyFlow: Delivery verification
• AI agents (Claude, GPT): Code generation

Roadmap: Jazzband is in early stages; upcoming steps:

1. Linear integration (read tickets, update status, add comments)
2. GitHub integration (create PRs, query status, add annotations)
3. Crosscheck integration (trigger reviews, get results)
4. AI coding agent integration (call AI for code generation)
5. VerifyFlow integration (trigger validation, get reports)

Practical Significance: Jazzband represents a new AI-assisted development paradigm ("professional tools + smart orchestration") with benefits:

• Respects existing tool investments (no need to replace Linear/GitHub).
• Better observability (public handoffs enable clear workflow status tracking).
• Lower lock-in risk (independent tools can be replaced gradually).

It serves as a bridge between AI coding assistants and enterprise development processes, helping teams synergize tools effectively.