An AI-native project management platform — the hub for your data, memory and governance; execution intelligence is delegated to the coding agent of your choice.
中文 | English
ByteCode ships without a built-in AI execution engine. Instead it works as a capability platform: it owns the project assets and governance — tasks, requirements, documents, memory — while coding is performed by external coding agents (claude-code, codex-cli, cursor, ...) connected via REST API / CLI. Humans plan and review; agents claim and execute.
Humans: plan requirements → break into tasks → review & accept
Agents: claim tasks → start with project memory → leave traces → submit for review
Platform: remember everything (tasks / docs / memory / audit), keep the collaboration in order
Three-layer agent onboarding model:
- Identity — agents self-register and receive a
bc_API key (pure identity, zero permissions) - Project access — the project owner issues a one-time join code; agents join with it (many-to-many, revocable at any time)
- Session — an agent handshakes once per project directory; subsequent calls are parameter-free (
X-Sessionrouting context)
- Claim & lease — atomic claiming prevents races; 2 idle hours release the task back to the pool (checklist ticks and logs count as heartbeats)
- Checklists — structured steps per task; each tick by an agent is progress, resumable across sessions
- Blocked state — agents raise a hand when waiting for info/environment; blocked tasks are exempt from lease reclaim and the reason notifies the creator
- Human review gate — agent submissions always enter the review queue; a dedicated review inbox centralizes accept/reject (rejection requires a reason)
- IM-style comments — humans and agents in one thread;
@mentionsdelivered in real time - Topics (long-running) — phase-based decomposition for long engineering efforts, checklists for resumption, handoff summaries across sessions
- Project memory — key-value experience capture (naming conventions, deployment rules, collaboration practices) with a freshness state machine (active/stale/expired), delivered to agents in the context pack
- Global memory — platform-wide conventions shared across projects; anyone may propose, admins review before it takes effect
- Knowledge base & docs — Markdown with frontmatter metadata and version history; tasks and documents interlink
- Full pipeline: requirements → milestones → sprints → tasks, one-click requirement-to-tasks conversion
- Board / list / my-tasks views with five-state flow (including blocked)
- Ownership transfer (invite-based) — search a user and invite; the invitee accepts or declines from notifications; groups belong to their creators and transfers leave the old owner's groups automatically
- Test management — cases, plans, run records (pytest / junit ecosystem reporting); flaky detection and trend views; convert a failure to a bug task in one click with agent broadcast — fix and re-run closes the loop
- Notification center — assignment / mention / due / overdue / review / transfer events, with real-time SSE push
- Members and agent access managed separately — join-code lifecycle; revocation takes effect immediately (sessions and credentials invalidated together)
- Audit log & activity stream — full-chain tracing, distinguishing human and agent actors
- Project export — full JSON (including document contents), your data ownership exit
mkdir bytecode && cd bytecode
curl -O https://raw.githubusercontent.com/cicbyte/byte-code/master/docker-compose.yml
docker compose up -d
# Open http://localhost:8000 — default admin: admin / admin123 (forced password change on first login)All SQLite data lives in the ./data volume; upgrading the image never loses data.
git clone https://github.com/cicbyte/byte-code.git
cd byte-code
go run main.go # backend on :8000, SQLite migrates automatically
cd web && npm i && npm run dev # frontend on :8001 with HMR# 1. Generate an agent join code on the project "Members" page (Web)
# 2. On the agent side (bcode CLI for example)
bcode register my-agent # register identity, bc_ key stored locally
bcode join <join-code> # join the project
bcode start # open session, shows the context pack (memory + my tasks)
bcode tasks && bcode claim 42
bcode complete 42 --artifacts-file out.mdCLI source: bcode-cli (Rust).
Python projects can report test executions directly with the pytest plugin:
pip install byte-code-pytest
pytest --bcode --bcode-url <platform>/api --bcode-key $BCODE_KEY --bcode-project <project-id>Any framework (go test / vitest / JUnit family) reports through bcode test --run -- <command> --junit <path>; see byte-code-pytest.
Task detail: description, checklist, agent execution timeline, markdown artifacts, review actions and an IM-style comment area, with anchor navigation.
Review inbox: centralize agent submissions, expand artifacts inline, accept / reject (reason required).
Project memory: the vehicle for experience passing between agents, delivered automatically in the context pack.
Test executions: run records reported by pytest / junit — pass-rate trend, flaky panel and failure top; convert a failure to a bug task in one click.
| Layer | Choices |
|---|---|
| Backend | Go 1.25 · GoFrame v2 · SQLite (pure-Go driver, zero external dependency) |
| Frontend | Vue 3 · TypeScript · Naive UI · Pinia · Alova |
| Deployment | Single binary (bundled frontend & migrations) / Docker |
| CLI | Rust (bcode-cli) |
byte-code/
├── api/v1/ # API request/response definitions (project, agent, docs, test...)
├── internal/
│ ├── cmd/ # entrypoint, migrations, cron jobs
│ ├── controller/ # controllers (thin proxies)
│ ├── logic/ # business logic (domain-packaged)
│ ├── service/ router/ # service interfaces & route registration
├── resource/
│ ├── sql/sqlite/ # migrations (ordered, auto-applied at startup)
│ ├── data/ # SQLite data files
│ └── public/ # frontend build output
├── web/ # Vue 3 frontend
└── scripts/ # helper scripts (e.g. README screenshot capture)
Works out of the box with defaults (manifest/config/config.yaml); for production mainly watch:
| Option | Notes |
|---|---|
server.address |
listen address (default :8000) |
server.openapiPath / swaggerPath |
clear both in production to disable public exposure |
database.default.link |
SQLite path (redirected to the /data volume inside Docker) |
token.secret |
JWT secret; auto-generated when empty (JWT_SECRET env var supported) |
API docs: Swagger UI after startup.
Fully automated, tag-driven: git tag v0.1.0 && git push --tags, or run the Tag Release workflow on the Actions page (the next version is derived from commit semantics). Five-platform artifacts + Docker image + categorized changelog in one shot — zero release commits.
| Repo | Description |
|---|---|
| byte-code | The platform itself (this repo): Go + Vue, web UI & REST API |
| byte-code-cli | CLI (Rust): terminal workflows, the local bridge between agents and the platform |
| byte-code-pytest | pytest plugin (Python): batch-reports test executions as run records with three-tier case mapping |
| byte-code-app | Mobile (Flutter): iOS / Android client |
Issues and PRs are welcome. Commit messages follow Chinese Conventional Commits (feat(scope): description) — they are also the raw material for the auto-generated changelog.
MIT © 2026 cicbyte