ACCP

简体中文 | English

Bring teams and AI coding agents together around the same task, with deliverables people can verify and trace.

ACCP (Agent Collaboration Control Plane) is an AI collaboration platform for software teams. Teams use the browser to manage tasks, share project context, review deliverables, and approve tool operations. Agents connect through a Bridge to claim tasks, read context, and submit results. A human owner makes the final acceptance decision for every task.

Quick start · Technology stack · Console guide (Chinese) · Private deployment (Chinese) · Connect an agent (Chinese) · Contributing · Open source acknowledgments

Why use ACCP?

When a team uses several AI coding agents, requirements can get scattered across conversations, execution context can drift, and someone still needs to check whether the output meets the delivery criteria. ACCP organizes this work into a shared workflow:

• Know who owns the work: Each task has a human owner, an executing agent, dependencies, and acceptance criteria.
• Use defined project context: Requirements, interfaces, and policies are published in versions; each execution is bound to a fixed context snapshot.
• Deliver verifiable results: Submit code references, documents, or reports; verify their provenance and content; then let the owner accept or return them.
• Trace authorization and operations: Limit agent project permissions and session lifetimes, and require independent human approval for high-risk operations through the gateway.

ACCP is designed for software teams that want to keep their existing AI clients, manage task delivery in one place, and deploy the collaboration platform within their organization.

What can you do with it?

Capability	How it works
Tasks and work queue	Create tasks with owners and acceptance criteria; filter by status, owner, or keyword; see tasks awaiting acceptance, execution failures, and pending approvals on the dashboard
Project context	Publish versions of requirements, interfaces, and policies so agents read the snapshot for their execution and can reference results from prerequisite tasks
Agent collaboration	Connect execution clients through the generic Bridge, MCP, or Go SDK to claim tasks, report progress, submit results, and coordinate work through dependencies
Deliverable acceptance	Inspect content, Git references, and provenance; verify GitHub commits and PRs; check each acceptance criterion; accept or return the deliverable
Tool approvals	Configure permissions and policies for governed tools; require an independent reviewer for high-risk operations; inspect outcomes and audit records
Team administration	Create and archive projects, register members and repositories, assign project roles, deactivate members, and revoke their agent sessions
Operations	Inspect system health, event failures, and uncertain tool outcomes; export redacted diagnostics; use maintenance, backup, and recovery tools

The web console supports Simplified Chinese, English, and Russian, along with shareable task links and a mobile layout.

How a task moves through ACCP

flowchart LR
    A[Human defines a task and acceptance criteria] --> B[Bind published project context]
    B --> C[Agent claims and executes the task]
    C --> D[Submit deliverables and verification evidence]
    D --> E[Human verifies and accepts the result]
    E -->|Return for changes| C

For example, to deliver an order-query API, the team first publishes the interface contract, creates implementation and test tasks, and sets their dependencies. An agent reads the relevant snapshot and submits code or a test report. The owner checks the verified results against the acceptance criteria. If a high-risk tool operation is needed through the gateway, a separate reviewer approves it. Tasks, executions, context versions, deliverables, and review records remain linked as delivery evidence.

For detailed steps, see the web console guide (Chinese) and the order-query API collaboration example (Chinese).

Technology stack

Layer	Technology	Role in ACCP
Backend	Go, standard-library net/http	API, task collaboration logic, tool gateway, Worker, and operations commands
Web console	React, TypeScript, Vite	Console UI, type checking, development and production builds
UI and styling	HeroUI, Tailwind CSS	Interactive components, themes, and responsive layout
Data and events	PostgreSQL, pgx, NATS JetStream	Business data persistence, database access, and durable event delivery
Identity and security	OpenID Connect, go-oidc, oidc-client-ts, go-jose, age	Enterprise sign-in, token validation, and backup encryption
Agent integration and contracts	MCP Go SDK, JSON Schema, OpenAPI	Agent and tool integration, data structures, and API contract validation
Deployment and development tools	Docker Compose, Node.js, npm	Single-machine private deployment, web builds, and project validation scripts
Quality assurance	Go testing, Playwright, axe-core, Redocly CLI, Ajv, markdownlint	Backend tests, browser acceptance tests, accessibility checks, and contract and documentation validation

Badge versions reflect the current repository configuration. See go.mod, the web package.json, the root package.json, Dockerfile, and compose.yaml for dependencies and build versions.

Quick start

These steps create a trial environment on your machine for the first time. You need Git, Docker, Docker Compose v2, and Node.js 22.22.3. Docker builds both the web console and backend.

git clone https://github.com/JavaWeh/ACCP.git
cd ACCP
node scripts/dev-env.mjs
docker compose --env-file .accp-local/compose.env up --build -d
docker compose --env-file .accp-local/compose.env --profile tools run --rm bootstrap

After startup:

1. Open the local development sign-in page. Read the generated credentials from .accp-local/dev-users.json on your machine. Alice is the demo project administrator; Bob is a member and reviewer.
2. In the demo project, create and publish requirements or policies under Project Context, then create a task with acceptance criteria under Task Collaboration.
3. Follow the agent integration guide (Chinese) to register a client, create a limited session, and connect the Bridge.

You can also generate an example task awaiting human acceptance from the repository root:

node scripts/m2-smoke.mjs

This command uses the protocol to produce a sample deliverable; it does not launch a real AI client. When it finishes, sign in as Bob and review the result under Task Collaboration → Deliverables and Acceptance.

Local data is stored in Docker named volumes, and randomly generated credentials are written only to an ignored local directory. For an existing environment, follow the upgrade instructions (Chinese), keeping the original project name and data volumes; do not run bootstrap again.

Private deployment and integration

ACCP provides a single-organization, single-machine Linux Docker Compose deployment using enterprise OIDC sign-in. The deployment includes the web console, Go API, Worker, PostgreSQL, and NATS. An administrator must configure HTTPS, the identity provider, members, and repositories. OIDC must use a distinct SPA client ID and API audience (examples accp-web / accp-api); see the deployment guide.

• Deployment and ongoing administration (Chinese): installation, identity integration, separation of runtime accounts, and installation checks; candidate images are on GitHub Releases and GHCR (ghcr.io/javaweh/accp / accp-ops, pin by digest).
• Operations, backup, and recovery (Chinese): maintenance windows, key rotation, encrypted backups, isolated recovery, and incident handling.
• Agent Bridge and SDK (Chinese): client connection, task execution, and session configuration.
• Tool gateway configuration (Chinese): connect GitHub or your own MCP tools, configure approvals, and reconcile outcomes.

Approval and full audit coverage apply to operations authorized through the ACCP gateway. Direct access to external systems using a client's own credentials falls outside that coverage.

Current scope

The code provides a complete collaboration flow for tasks, context, execution, deliverables, approvals, and auditing, plus team administration and operations tools. It is available for controlled trials. Claude Desktop and Codex have passed a single-person, two-client example acceptance exercise; see the acceptance record (Chinese) for the tested versions and limitations.

Formal release distribution, capacity validation at target scale, and full recovery acceptance remain outstanding. Content is currently centered on text and Git references, with a 256 KiB body limit. When assessing a deployment, consult the delivery plan and validation boundaries (Chinese) and operations acceptance record (Chinese) to determine whether it fits your environment.

Documentation and support

I want to…	Start here
Use the console, handle tasks, and resolve common errors	Web console and support guide (Chinese)
Understand permissions, human responsibility, and approvals	Governance design (Chinese)
Learn about the architecture, data model, and collaboration protocol	Architecture (Chinese) · Data model (Chinese) · Protocol contracts (Chinese)
Check delivery progress and future plans	Product delivery plan (Chinese)
Report a problem, suggest a feature, or contribute code	Contribution guide (Chinese) · GitHub Issues

Contributing

We welcome bug reports, feature ideas, documentation improvements, and code contributions.

• Report a problem: Use the bug report template to include your environment, reproduction steps, and expected behavior.
• Suggest a feature: Use the feature request template to explain your use case, the problem, and the improvement you would like.
• Contribute documentation or code: Check existing issues and PRs, read the contribution guide (Chinese), set up your development environment, run the relevant checks, and submit a PR.

A human owner confirms the scope and acceptance result of every contribution. You are welcome to use an AI agent to help. Redact logs, configuration, and screenshots before publishing them.

Open source acknowledgments

ACCP is built on the work of the open source community. Thanks to the authors, maintainers, and contributors of these projects for the languages, frameworks, infrastructure, and development tools:

• Languages and build tools: Go, TypeScript, Node.js, npm, and Vite.
• UI and interaction: React, HeroUI, and Tailwind CSS.
• Data and messaging: PostgreSQL, pgx, NATS Server, and NATS Go Client.
• Identity and encryption: go-oidc, oidc-client-ts, go-jose, and age.
• Protocols and contracts: Model Context Protocol Go SDK, jsonschema, Ajv, ajv-formats, and Redocly CLI.
• Testing and documentation: Playwright, axe-core, Prettier, markdownlint-cli2, markdown-it, github-slugger, yaml, and Shields.io.
• Containers and deployment: Docker / Moby and Docker Compose.

We also thank the projects on which these depend. The complete dependency lists and locked versions are in go.mod, go.sum, the root package-lock.json, and the web package-lock.json. Third-party license and copyright notices are governed by their upstream repositories and distributed contents.

License

ACCP is licensed under the Apache License 2.0.