SharperFlow Open Source

Concord

A workflow engine over one durable record. Approved requirements, work state, evidence, and research — reachable only through typed, authorized operations.

View on GitHub Core architecture

install — linux amd64

python3 concord-installer.py install --version vX.Y.Z
concord --version

Download the installer from the latest release. It verifies the published checksum and bundle before it changes anything.

the problem

Coordination held together by prompts

When several agents change related parts of one project, each change can pass review while the combined result breaks an approved requirement. Most tooling answers this in the prompt: roles, handoffs, and a description of the process. It holds while every agent follows it, and nothing outside the prompt checks the result.

Completion is an assertion — the agent’s report is the only record
The goal drifts after approval, and nothing compares delivery against it
Two agents write the same boundary and find out at merge

proof

Typed operations, typed refusals

Captured from a live Concord session — the one this page was built in.

concord --version

v8.26.7

start work from the terminal

concord zl work-9f27c4e1 -- "ship the feature"

Start or resume a workspace without the UI.

concord_work_transition — record_proposal

{"outcome": "error",
 "error": {"kind": "invalid_input",
           "message": "missing payload field action_id"},
 "recovery_action": {"kind": "reread_entities"}}

A refusal names the failed condition and the route out. effect_state: none — nothing was written.

how it works

State an agent cannot write around

Completion carries evidence

A terminal transition refuses until verification, review, and commit evidence are bound to the work.

The goal is fixed first

The operator approves outcome predicates before work starts. Acceptance compares delivery against them.

Collisions refuse early

Each change declares the Domains it writes. A second change into a claimed Domain refuses until the overlap is resolved.

Refusals name the remedy

Every refusal is typed and states which condition failed, so a blocked agent reads the route out.

under the hood

One authority

Everything durable lives in one local SQLite record: requirements, work state, evidence, knowledge, research. Read projections derive from that record and can be rebuilt.

A Go core owns the domain model, authorization, and workflow logic. The OpenCode adapter stays a narrow transport: typed schemas, session identity, and nothing else.

Honest cost: Agents earn each transition. A session that skips a step is refused, not obeyed.
Releases: Linux amd64, checksum-verified installer, recoverable mid-operation.
License: MIT-licensed Go core.

Coordinate the next thing you ship

Install the core, bootstrap one product, and let the record — not the prompt — hold the process.

View on GitHub Core architecture