work CLI - Revolutionary Mixed Human-Agent Teams

👨🏻‍💻 Dynamous Kiro Hackathon Submission: The submission was released on Jan 30, 2026 as v0.2.7 and can be cloned as git clone --branch v0.2.7 https://github.com/tbrandenburg/work.git

https://github.com/user-attachments/assets/4019fdba-05bc-4008-8c26-75e37c43672f

The Story Twist: From Human-Orchestrated to Equal Partnership

Before: Human developers orchestrated agents to do their work - mostly one-developer scenarios.

Now: work enables revolutionary mixed human-agent teams where everyone operates on the same level, using the same communication mechanisms and development processes.

The Innovation

work gathers all participants - humans and agents - into one unified system. When work runs on schedule, it triggers both humans and agents to work on their tasks. Assignees can be set by anyone, but the engine keeps running autonomously:

• Agents get notified and work on their tasks
• Agents can assign tasks to humans when needed
• Everyone operates on equal footing
• Same development cycle beat glues everyone together
• Interoperability connects any task management system or notification target
• Future A2A networks for deeper agent-to-agent integration

This is the actual revolution: true mixed human-agent teams working together seamlessly.

💡 Stay tuned: The UI for work is in development at https://github.com/tbrandenburg/workui

Choose Your Path

🚀 Just want to try it? → 5-Minute Quick Start

📚 New to task management CLIs? → Complete GitHub Workflow Tutorial

🔧 Integrating with existing workflow? → GitHub Authentication Guide

🤖 Setting up AI agents? → AI Scrum Examples

❓ Having issues? → Documentation Index

Installation

npm install -g @tbrandenburg/work

Alternatively with npx leveraging the stateless nature of work:

npx @tbrandenburg/work

Real-World Examples

For Solo Developers

# Track tasks in local filesystem
work context add my-project --tool local-fs --path .
work context set my-project

# Set up Telegram notification target
work notify target add telegram --type telegram --bot-token YOUR_BOT_TOKEN --chat-id YOUR_CHAT_ID

# Create and manage work items
work create "Add dark mode" --kind task
work list

# Send Telegram notification
work notify send where kind=task to telegram

For Teams

# Set up GitHub authentication
gh auth login

# Create team context and authenticate
work context add team-project --tool github --url https://github.com/team/project
work context set team-project
work auth login

# Set up Telegram notifications for team coordination
work notify add telegram --type telegram --bot-token YOUR_BOT_TOKEN --chat-id YOUR_CHAT_ID

# Create and assign work with notifications
work create "Deploy v2.1" --assignee devops-team
work notify send where assignee=devops-team to telegram  # Alerts team via Telegram

For AI Agents

#!/bin/bash
# AI agent workflow script

# Set up context (run once)
work context add ai-project --tool github --url https://github.com/team/ai-project
work context set ai-project
work auth login

# Option 1: Bash script handler
work notify target add ai-agent --type bash --script ./ai-agent-handler.sh

# Option 2: ACP-compliant AI coding assistant
work notify target add code-reviewer \
  --type acp \
  --cmd "opencode acp" \
  --system-prompt "You are a senior code reviewer. Focus on code quality, security, and best practices."

# Agent creates and manages work items
work create "Refactor user service" --assignee ai-agent --kind task --priority critical

# Notify AI agents about critical tasks
work notify send where priority=critical to ai-agent

# Send features for AI code review
work notify send where kind=feature and state=new to code-reviewer

# Agent does its work in background...
# Add work notify to cron and let it work continuously on tasks...
# Example: */5 * * * * cd /path/to/project && work notify send where priority=critical to ai-agent

💡 Coming Soon: Agent-to-Agent (A2A) notification targets for deeper AI agent network integration.

Prerequisites

• Node.js 18+ (LTS recommended)
• npm or yarn package manager
• Git

AI Agent Skills Installation

For AI agents using the work CLI, install both the CLI tool and the comprehensive usage skill:

# Install the work CLI globally
npm install -g @tbrandenburg/work

# Install the work CLI usage skill for your AI agent
npx ai-agent-skills install tbrandenburg/work/work-skill

# Or install for a specific agent
npx ai-agent-skills install tbrandenburg/work/work-skill --agent [YOUR_AGENT]

The work CLI skill provides comprehensive guidance on:

• Quick setup for local filesystem and GitHub backends
• All command categories with practical examples
• Context management and authentication
• Notification system integration patterns
• Advanced workflows for team coordination and CI/CD
• Troubleshooting common issues

This enables AI agents to effectively use the work CLI for mixed human-agent team coordination.

Pre-Installed Teams

The work CLI comes with two ready-to-use team templates that are automatically created on first use:

Software Development Team (sw-dev-team)

• 3 AI Agents: Technical Lead, Senior Developer, Scrum Master
• 2 Humans: Product Owner, QA Engineer
• Commands: /code-review, /technical-planning, /mentoring-session

Research Team (research-team)

• 3 AI Agents: Senior Researcher, Data Analyst, Research Coordinator
• 3 Humans: Lab Manager, Domain Expert, Research Assistant
• Commands: /design-experiment, /literature-review, /data-analysis

# Teams are automatically created on first use
work teams list

# Explore team details
work teams show sw-dev-team
work teams agent sw-dev-team/tech-lead

# Use agents in work items
work create "Code review needed" --assignee tech-lead

For complete team management capabilities, see the work teams specification.

Upcoming Features

Task Management Adapters

• Linear: Native Linear API integration for issue tracking
• Azure DevOps: Full Azure DevOps work item management
• Jira: Complete Jira project and issue support

Notification Targets

• Claude Code: Direct integration with Claude coding assistants
• Codex: OpenAI Codex model notifications
• Opencode: Open-source code generation models
• GitHub Copilot: GitHub Copilot workspace integration
• A2A: Agent-to-Agent communication protocols

Automation Features

• Webhook Triggering: HTTP webhook support for external system integration
• Cron Helper: Built-in scheduling utilities for automated task management

Development

Setup Development Environment

# Install dependencies
npm install

# Run tests
npm test

# Run linting
npm run lint

# Build project
npm run build

# Format code
npm run format

Using Makefile

The project includes a Makefile for unified development commands:

# Install dependencies
make install

# Run all checks (lint + test)
make check

# Run full CI pipeline
make ci

# Clean build artifacts
make clean

# Format code
make format

Project Structure

work-cli/
├── src/
│   ├── cli/           # Command parsing and CLI interface
│   ├── core/          # Core engine and graph logic
│   ├── adapters/      # Backend implementations
│   ├── types/         # TypeScript type definitions
│   └── utils/         # Shared utilities
├── tests/
│   ├── unit/          # Unit tests (70%)
│   ├── integration/   # Integration tests (20%)
│   └── e2e/           # End-to-end tests (10%)
├── docs/              # Documentation
└── scripts/           # Build and development scripts

Code Quality

This project maintains high code quality standards:

• TypeScript: Strict mode with explicit types
• Testing: Vitest with >60% coverage requirement
• Linting: ESLint with TypeScript rules
• Formatting: Prettier for consistent code style
• CI/CD: GitHub Actions for automated testing

Available Scripts

| Script | Description | | -------------------- | ------------------------------ | | npm test | Run all tests | | npm run build | Build TypeScript to JavaScript | | npm run lint | Run ESLint | | npm run format | Format code with Prettier | | npm run type-check | Run TypeScript type checking | | npm run clean | Clean build artifacts |

Target Users

• Applied AI Engineers: Setting up agent harnesses needing interoperable task management interfaces
• Product & Business Owners: Letting their ideas get reality through autonomous agent teams
• DevOps Engineers: Who need to integrate task management into CI/CD workflows and automation
• Technical Project Managers: Who need unified visibility across different project management systems

Documentation

Comprehensive technical documentation is available in docs/:

• Complete Documentation Index - Overview of all documentation
• CLI Specification - Complete command reference
• Architecture Overview - Multi-backend design
• User Journey Guide - Context and querying
• Performance Requirements - Quality attributes

Contributing

1. Follow the coding standards in AGENTS.md
2. Write tests following the 70/20/10 pyramid
3. Update documentation for new features
4. Ensure all tests pass and coverage remains >60%

License

MIT License - see LICENSE for details.