ChimpHands

In brief: ChimpHands is TestChimp's native cloud agent that runs QA workflows on your CI machine with full repo context, orchestrated by the platform and reachable from automations or in-product chat.

ChimpHands is TestChimp's own native cloud agent for QA workloads. Unlike third-party coding agents you wire in separately, ChimpHands is built into the platform: one-click setup, workflow-level auditability, and a chat UI that stays connected to the same session running on your repository's CI machine.

ChimpHands runs on your GitHub Actions runner (not on TestChimp infrastructure), so the agent has full code context—the same checkout, branches, and secrets your team already uses for CI. Under the hood it is built on OpenCode with the TestChimp skill and MCP, and routes LLM calls through GPT 5.6-range models tuned for cost-effective QA execution.

What ChimpHands does

ChimpHands executes the same catalog workflows you run locally with /testchimp—fix-issue, implement, upkeep, author-plans, instrument-truecoverage, and the rest. It is the recommended invocation path for automations and for interactive QA from the ChimpHands page in the product.

Typical uses:

• Event-driven QA — automations dispatch workflows when issues, plans, batches, or releases change.
• Interactive QA — start a session from ChimpHands chat, Plans, or Issues with platform context pre-filled.
• Async housekeeping — upkeep, fix failing tests, TrueCoverage instrumentation, and similar workflows that benefit from full repo access without tying up your dev-agent subscriptions.

Built in—not bolted on

Bring-your-own cloud agents (GitHub Issue listeners) expect you to commit mcp.json, install the TestChimp skill, and wire TESTCHIMP_API_KEY per host (Cursor dashboard, Copilot MCP settings, Actions secrets, and similar).

ChimpHands ships with all of that on every run. The GitHub Actions job installs OpenCode, @testchimp/cli@latest, and clones testchimp-skills into .agents/skills/testchimp before testchimp chimphands serve starts. You add one repo secret (TESTCHIMP_API_KEY) at setup—not ongoing MCP dashboard work per agent product.

	ChimpHands	Typical BYO cloud agent
Skill + CLI on the runner	Installed automatically each job	You commit skill paths and MCP config
TestChimp MCP / API auth	Injected from TESTCHIMP_API_KEY	Per-host secret stores and mcp.json placeholders
Platform entity context in chat	Native picker + serialized refs	Paste ids or write custom tool glue
Session ↔ CI tunnel	Built into ChimpHands UI	Separate product UI or issue thread

That packaging is why ChimpHands is the default automation invocation strategy—less wiring, same /testchimp catalog.

Chat with platform and repo context

ChimpHands chat is not a generic coding-agent window pasted into TestChimp. It is wired to platform objects and the live CI worktree so you attach precise context as removable tags—without re-explaining what you mean.

Platform entities (no copy-paste ids)

Use the + menu in the composer to attach TestChimp entities:

Entity	Typical use
Story	Scope or implement a requirement with ordinal id in the prompt
Scenario	Test-level handoff from Plans
Issue	Fix or investigate with bug context already on the platform
Test	Point at a specific SmartTest execution
Release	Gate or run QA against a release lifecycle
Automation batch	Investigate a failed CI / SmartTest batch by batch id

Each tag opens a searchable picker (same entity board patterns as InfiniTrace). References serialize into the message as stable ref: lines—ordinal ids for stories, scenarios, and issues; release labels; platform ids for batches—so the agent on CI receives unambiguous pointers.

Handoffs from Plans and Issues can pre-fill entity context (and optional line ranges) when you open ChimpHands from those surfaces.

Repo files and line ranges

While a session is running on CI:

• Repo explorer — browse the live worktree (or GitHub branch fallback) and open files in the side pane.
• Line ranges — select lines in the diff or content editor and add them as context tags (path:start-end).
• Whole files — drag a file from the changed-files list or explorer into the composer, or attach the full file path.

The agent sees ref: <path> lines: <start>-<end> (or full-file refs) in the prompt—same ergonomics as @-mentioning files in IDE agents, but against the checked-out branch on your runner.

Upload local files

Upload local file in the + menu sends artifacts through TestChimp storage. When ready, the tag resolves to a short-lived accessible URL in the serialized message—useful for screenshots, logs, or exports that are not yet in the repo.

Collaborative editing

The file diff pane streams agent edits from the CI worktree. You can:

• Review side-by-side or unified diffs as the agent works.
• Switch to content view and edit files yourself when the runtime allows—changes write back to the worktree via writeWorktreeFile so you and the agent share the same checkout.
• Save (Ctrl+S) human edits alongside agent turns.

That gives feature parity with typical cloud coding agents (file refs, uploads, inline edit) while keeping platform entity context and workflow execution linkage that generic agents do not have out of the box.

How it runs

Setup is designed to be one-click after you connect GitHub:

1. Install the TestChimp GitHub App and map the repository for your project.
2. Install the ChimpHands workflow — TestChimp commits .github/workflows/chimphands.yml to your repo (directly or via PR when branch rules require it).
3. Add TESTCHIMP_API_KEY as GitHub Actions secrets on the repo.

When a session starts (from chat or an automation), TestChimp:

1. Creates a ChimpHands session tied to your project and workflow execution.
2. Dispatches the ChimpHands GitHub Actions workflow with session_id, prompt, and optional branch.
3. The job checks out your branch, installs OpenCode + @testchimp/cli, clones the TestChimp skill, and runs testchimp chimphands serve against a local OpenCode server.
4. The runtime registers with TestChimp and opens a tunnel so the platform UI can stream messages, tool output, and file diffs in real time.
5. On completion, changes are delivered via pull request (PR-only mode by default).

You can open the linked GitHub Actions run from the session or workflow execution detail for raw CI logs.

Trigger (automation / chat)  →  ChimpHands session  →  GitHub Actions job
                                                              ↓
                                                    checkout + OpenCode + skill
                                                              ↓
                                                    /testchimp workflow on CI
                                                              ↓
                                         tunnel ↔ TestChimp UI (live or async)
                                                              ↓
                                                    PR + workflow execution status

Human in the loop

Most cloud agents are either fully async (fire a job, wait for a PR) or fully interactive (you sit in their chat UI). ChimpHands bridges both:

Mode	What happens
Async	Automations or non-interactive workflows run to completion. You review the PR and workflow execution timeline when done. Optional human approval gates pause before invoke or before plan execute.
Interactive	Open ChimpHands in TestChimp and chat with the agent while it runs on CI. You see reasoning, tool calls, and file diffs as they happen.
Async → in-convo	If the agent needs clarification mid-run, you can join the same session in the ChimpHands UI—no new conversation, no copy-pasted context. Pending user messages are delivered to the runtime on CI so the turn continues in place.

That seamless handoff is difficult with external agents (labelled GitHub issues or generic cloud coding products): you usually lose session continuity or switch UIs. ChimpHands keeps one session id, one workflow execution, and one GitHub Actions run from start to finish.

For work that needs heavy pair-programming with your everyday dev agent, use a local agent with the TestChimp skill instead—see Best practices.

Where to configure

Surface	Path
ChimpHands chat & setup	ChimpHands in the sidebar (/chimphands)
GitHub App & repo	Project Settings → Integrations → GitHub
Automations using ChimpHands	Workflows → Automations — choose ChimpHands as invocation strategy
Runs & approvals	Executions → Workflow Executions
Credits & budget	ChimpHands credits popover on the ChimpHands page; org billing for overage

Next steps

• Meet ChimpHands (announcement)
• Why ChimpHands — Cost isolation, tokenomics, and budget-aware QA
• Best practices — Authoring requirements, automations, and when to use local agents
• Cloud agents for automations — ChimpHands vs bring-your-own-agent strategies
• Automations overview — Event-driven workflow runs