____ _                 _        _____                                    _       
  / ___| | __ _ _   _  __| | ___  |_   _|__  __ _ _ __ ___  _ __ ___   __ _| |_ ___ 
 | |   | |/ _` | | | |/ _` |/ _ \   | |/ _ \/ _` | '_ ` _ \| '_ ` _ \ / _` | __/ _ \
 | |___| | (_| | |_| | (_| |  __/   | |  __/ (_| | | | | | | | | | | | (_| | ||  __/
  \____|_|\__,_|\__,_|\__,_|\___|   |_|\___|\__,_|_| |_| |_|_| |_| |_|\__,_|\__\___|

Claude Teammate is an AI bot that works around the clock - picking up tickets, writing plans, opening PRs, acting on feedback, and reviewing code. No stand-ups. No Slack pings. No passive-aggressive "per my last email." Just like your best teammate, minus the coffee breath.

Assign it tickets. It ships.

| | Step | What happens | | ------ | ------------------ | ----------------------------------------------------------------------------------------------------- | | 01 | Assign the ticket | Assign the Jira ticket to the bot. | | 02 | It plans | Reads the codebase and writes a plan. You give feedback, it revises. Nothing moves until you approve. | | 03 | It ships | Opens a PR. Responds to feedback. Keeps going until it's merged. | | 04 | It remembers | Retains build commands, known pitfalls, and lessons from every task it has shipped - so the next ticket in the same epic starts smarter. |

What's New

• Parallel multi-worker processing - run multiple agents simultaneously, each handling a different epic without stepping on each other.
• Google Chat bot - receive ticket updates and reply to clarification questions directly from Google Chat.
• Phased PR implementation - large implementations are broken into reviewable phases so nothing lands in one unreviewable mega-PR.
• Stuck-task auto-retry - if Claude CLI fails mid-task, the worker automatically retries up to 5 times before escalating with a Jira comment.
• Live dashboard - real-time heartbeat cards, stuck-task table, and per-issue log viewer with download.
• No-code deliverable attachments - for research and document tasks the bot uploads output files directly to the Jira issue.
• Self-improving skills - the worker auto-detects failed/bypassed Skill tool calls and opens PRs that patch the offending skill file; an optional proactive mode samples clean tasks for further improvements.

Claude Teammate is right for you if

• ✅ You want Jira tickets to turn into merged PRs without manual handoff
• ✅ You want PR review comments acted on, not just acknowledged
• ✅ You need a reviewer that always shows up and leaves structured feedback
• ✅ You want automated PR review without adding another review subscription on top of Claude
• ✅ You want an AI that remembers - which repo, what's shipped, what breaks, what to avoid
• ✅ You want the agent running in its own working environment so it can test code and verify real outputs
• ✅ You want this running on your own infrastructure
• ✅ You want multiple tickets worked in parallel without interference

How It Works

Review Human PRs Too

Claude Teammate is not limited to tickets it implemented itself. Add it as a reviewer on a human-authored pull request and it will read the diff, inspect the repository, and leave structured review feedback. This can be an alternative to paid tools like CodeRabbit or GitHub Copilot code review.

It Remembers

Every epic has its own memory. The bot picks up exactly where it left off - no matter how much time has passed.

That memory is built from more than the original Jira description. Claude Teammate updates it from planning, implementation, review comments, and recurring human feedback so future tickets inherit the durable parts of the work instead of starting from scratch.

memory/
└── {domain}/
    └── {workspace}/
        └── epic-{jira-key}.md

| Field | What it stores | |---|---| | jira_key / jira_url | Canonical epic identity | | repos | Shared target GitHub repositories for the epic | | facts / guardrails | Reusable lessons, build quirks, verification workflows, recurring human feedback, and what-not-to-do notes for the epic |

The memory stays compact on purpose. It is cleaned up, deduplicated, and summarized over time so later tickets can reuse the important context without dragging an ever-growing prompt window behind them.

Quickstart

Requirements:

• Node.js 20+
• Claude CLI installed and authenticated
• A Jira API token
• A GitHub PAT with repo + PR permissions

Installation

npm install -g claude-teammate

Run tm8 as a dedicated non-root OS user. On a VM, create that user and hand ownership of the workspace and runtime directories to it before starting the worker.

Example VM setup for a dedicated service user:

sudo npm install -g claude-teammate
sudo useradd --create-home --shell /bin/bash tm8
sudo mkdir -p /home/tm8/.tm8
sudo chown -R tm8:tm8 /home/tm8/.tm8
sudo chmod -R u+rwX /home/tm8/.tm8
sudo chmod -R a+rX "$(npm prefix -g)/lib/node_modules/claude-teammate"
sudo su - tm8
claude login
tm8 start

If you run tm8 start --local, also hand ownership of that project directory to the same user before starting the worker.

start creates ~/.tm8/.env on the first run. If that config already exists with the required values, setup is skipped and your credentials are not prompted for again.

# .env file generated by `tm8 start`
JIRA_BASE_URL=https://yourorg.atlassian.net
[email protected]
JIRA_BOT_API_TOKEN=...
GITHUB_PAT=ghp_...

To run multiple agents on the same machine, use --local to store agent status and memory in the current working directory.

To upgrade to latest version

npm install -g claude-teammate@latest

Check or stop the worker with:

sudo su - tm8
tm8 status
tm8 stop

Runtime files and memory are stored in:

~/.tm8/
├── .env
├── .claude-teammate/
|   ├── repos/
|   ├── worker.log
|   ├── worker.pid
|   └── state.json
└── memory/
    ├── skill-fixes.json          # self-improve event log (rolling, max 200)
    └── {domain}/
        └── {workspace}/
            ├── epic-{jira-key}.md
            └── issue-{jira-key}.md

Self-Improving Skills

The worker watches every Claude task for Skill tool failures (direct errors, MUST/MANDATORY bypass, silent fallback to a different tool). When detected, it auto-generates a patch and opens a PR against the skill file — repo-scoped skills get a PR in that repo, global skills (~/.claude/skills/<name>) are patched in place with a timestamped backup under .backups/.

Always-on (reactive fix mode) — no setup required. Cooldown: 30 min, threshold 2 successful fixes per (skill, errorType).

Optional: proactive improvement — on otherwise-clean tasks, sample a fraction and ask Claude whether the skill could be improved. Disabled by default (cost-bounded). To enable, add to ~/.tm8/.env:

SKILL_IMPROVEMENT_PROACTIVE=true
SKILL_IMPROVEMENT_SAMPLE_RATE=0.1     # fraction of clean tasks sampled (0.0–1.0)

Restart the worker (tm8 stop && tm8 start) to pick up the change. Cooldown: 24h per skill.

Optional override: TM8_EVENTS_ROOT=/custom/path redirects memory/skill-fixes.json away from ~/.tm8 (tests, multi-tenant deploys).

Inspect activity:

cat ~/.tm8/memory/skill-fixes.json   # rolling log of fix attempts + statuses
tm8 dashboard                        # /api/skill-fixes + /skill-fixes/stats UI

Event statuses: patched, patched-with-backup, pr-created, no-fix, cooldown, lock-skipped, not-found, scope-excluded, patch-failed, generation-error.

Detection is fire-and-forget — never blocks or affects task return values.

Google Chat Integration

Claude Teammate can post ticket updates and receive replies via a Google Chat bot.

Requirements:

• A Google Cloud service account with chat.bot scope
• GOOGLE_APPLICATION_CREDENTIALS pointing to the service account JSON key

Additional env vars:

GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
GOOGLE_CHAT_PORT=3100   # optional, default 3100

Start the Google Chat listener alongside the main worker:

tm8 start

The listener starts automatically when GOOGLE_APPLICATION_CREDENTIALS is set.

FAQ

How is this different from just prompting Claude directly? Claude Teammate is a persistent, scheduled process. It doesn't wait for you to type - it polls, acts, and remembers.

What happens if a Jira issue lacks context? It asks. The bot comments on the Jira issue with clarifying questions and waits for answers before doing anything.

Can it handle multiple Jira workspaces and GitHub repos? Yes. Each epic is scoped to its own Jira domain and workspace, and can map to one or more GitHub repositories.

Does it understand the codebase or just generate generic code? It reads the actual repository before writing anything - structure, conventions, existing patterns. The plan it proposes is specific to your code, not a template.

Can it test code and verify UI changes? Yes. It works in its own cloned working environment, can run the repo's test and build commands, and can use Playwright to take screenshots and verify frontend changes instead of relying only on the diff.

Can I use Claude skills or MCP, and does it respect CLAUDE.md? Yes. Claude skills, configured MCP servers, and repo instructions in CLAUDE.md are available and respected just like they are in a normal Claude-driven workflow. Playwright MCP is built in and enabled by default so challenging frontend tasks can be verified in-browser.

What happens if Claude CLI fails mid-task? The worker enqueues the task for automatic retry. It retries up to 5 times (polling every 15 minutes). If all retries fail, it posts a Jira comment and drops the task so other tickets are not blocked.

Can it work on multiple tickets at the same time? Yes. Run additional agents with tm8 start --local in separate project directories. Each agent is isolated and handles its own set of epics without conflicting with others.

Roadmap

• GitLab support
• Bitbucket support
• Slack and Teams integration

Contributing

Contributions are welcome. Open an issue to discuss before submitting large changes.

Community

• GitHub Issues - bugs and feature requests
• GitHub Discussions - ideas and questions

Disclaimer

This software is provided "as is", without warranty of any kind. The authors and contributors are not responsible for any damage, data loss, or unintended consequences arising from the use or misuse of this project. Use at your own risk.

License

MIT © 2026 Claude Teammate