Skip to content

Assync

The runtime for coordinated AI agents.

AI agents can generate code, review changes, and analyze systems. The difficult part is controlling who may do what, coordinating their work, preserving evidence, and stopping unsafe actions before they happen.

Assync provides a local runtime for missions, roles, authorization, evidence, human decisions, and auditable agent workflows.

Get started View on GitHub Read the architecture

Define missions. Assign roles. Restrict capabilities. Collect evidence. Require human decisions. Audit everything.

What is Assync?

Assync is a local runtime and governance layer for coordinated AI-agent workflows. It runs entirely on your machine as a Python CLI (assync) and a filesystem-backed store — no server, no external service, no account.

It is the first MVP release. It implements:

  • mission orchestration with typed mission states
  • role-based execution, with separation-of-duty enforcement
  • default-deny authorization and capability intersection
  • deterministic synthesis of agent-run reports into one recommendation
  • findings, evidence, and blocking logic
  • human approval gates and auditable decisions
  • restricted local-command execution and deterministic mock adapters
  • atomic filesystem storage and mission locking
  • a complete CLI workflow

What problem does it solve?

Coordinating more than one AI agent (or more than one run of the same agent) on a piece of work raises the same questions every time: which agent is allowed to do what, right now? What happens when two agents disagree? What evidence backs a claim that something was verified? Who has to approve before a risky action happens? What actually happened, in order, and can it be reconstructed later?

Assync answers these structurally, not by trusting agent output. A mission declares scope and required roles up front. Authorization is calculated centrally as an intersection — no role or adapter can grant itself more than it was given. A synthesis engine combines run reports deterministically, with no LLM in that step, and can never recommend COMMIT_GO, PUSH_GO, MERGE_GO, or RELEASE_GO on its own. Anything blocking goes to a human decision, never an automatic resolution.

How does it work?

flowchart LR
    A[Mission] --> B[Role selection]
    B --> C[Authorization calculation]
    C --> D[Agent runs]
    D --> E[Findings and evidence]
    E --> F[Synthesis]
    F --> G{Human decision required?}
    G -- yes --> H[Human decision]
    H --> I[Completed or Aborted]
    G -- no --> I[Completed or Aborted]

See Mission Orchestrator for the full, precise workflow, including locking and failure handling.

How do I install it?

git clone https://github.com/kalimer00/assync.git
cd assync
python3 -m venv .venv
source .venv/bin/activate
pip install .

Assync is not currently published to PyPI — install from a cloned checkout. See Installation for the full, verified sequence.

What can I try immediately?

assync --help
assync role list

The Quick Start walks through registering a project, creating a mission, running it against the deterministic mock adapter, and inspecting findings, synthesis, decisions, and the audit trail — using only commands that were executed against the real CLI before publishing this page.

What security boundaries does it enforce?

  • Default-deny authorization. No capability exists unless both the role and the active authorization grant it — see Authorization Model.
  • No self-authorization. No synthesis result, adapter, or role can grant itself a capability; escalation only happens through an APPROVED human decision.
  • Restricted subprocess execution. The local-command adapter never uses a shell, checks an executable allowlist, hard-denies git push/merge/clean, and redacts credential-shaped values from captured output.
  • No hidden reasoning. Structured reports carry only summary, recommendation, confidence, findings, evidence, assumptions, limitations, and required human decisions — never a raw chain-of-thought.

Full detail, including current limitations, is in the Security Model.

What is intentionally outside the MVP scope?

  • No process sandbox beyond an executable allowlist, timeout, and output cap — this is not a hardened isolation boundary.
  • No production credentials or autonomous production actions exist anywhere in this codebase.
  • No PyPI package yet; installation is from source.
  • No remote/cloud provider adapters — only a deterministic mock adapter and a restricted local-command adapter exist today. Future provider integrations are documented as interfaces, not implemented.

See Known Limitations for the complete, repository-sourced list.

Contributing and license

This repository does not yet publish a CONTRIBUTING guide or a LICENSE file. Until those are added, treat the repository as all-rights-reserved by default and open a GitHub issue before submitting substantial changes.