Purpose, mechanism, evidence

Keep AI-assisted work accountable to the repository.

The Kit keeps project context and work results in the repository, then checks defined workflow rules around your chosen AI assistant. You still own the requirements and the decisions.

Current package: 1.1.0. The facts below are generated from this checkout; dated observations retain their original scope.

What that means in everyday work

A contract names the permitted action and its conditions. A gate is an executable check of those conditions. Evidence records the observed result and its scope. A handoff gives a later session the current repository context and next step.

For example, you can discuss a fix in an ordinary browser chat, run the bounded local workflow, review its recorded checks and continue in another chat from the generated successor package. The assistant does not need direct shell access: File Transfer and Copy and Paste are supported paths, alongside Agent Direct and the experimental GUI.

Executable checks add something beyond a prompt or documentation template: they can report a block, check a specific revision or verify required evidence. They do not validate every requirement semantically. A test count, choice of Python library, release DOI or community size alone does not establish engineering quality or deployment suitability.

Interaction paths and their requirements · Inspect the evidence bindings

Good fit

Maintainers of continuing projects

Solo maintainers and small teams using AI across multiple sessions, models or executors, especially where documentation, review, release decisions and project history must remain inspectable.

Git-backed software and documentation repositories are the architectural target. Python is a reference profile, not a promise that every language or repository type has equally mature support.

Consider the overhead

Start with a bounded adoption

The Kit expects Git knowledge, explicit contracts and a maintainer willing to inspect evidence. For a disposable experiment, the state files and closeout steps may cost more than they help.

It does not supply the coding model, replace your IDE, decide whether requirements are correct or guarantee a safe change merely because checks are green.

What the mechanisms are intended to improve

Benefits with explicit tradeoffs

NeedKit mechanismPractical benefitCost or limit
Continue after a chat switchRepository state and generated successor packagesRecover inspectable context without relying solely on chat memory.State and projections must stay current; stale evidence can block.
Review a bounded actionCommand manifest, safety metadata and guarded workflowsMake the requested action and its effects easier to inspect.Guards cover defined rules; they cannot detect every semantic error.
Close PRs and releases consistentlyExpected-head checks, CI readiness and release consentKeep identity, approvals and evidence associated with the operation.GitHub state, network availability and configured CI remain dependencies.
Change executorVersioned contracts, evidence and transport boundariesKeep project context outside a particular assistant.Executor integrations need their own validation and permissions.

These are mechanism-based benefits, not measured claims of faster development, zero drift, fewer defects or lower total cost. The Kit workflow does not require an LLM API; your chosen assistant, hosting and CI can still incur costs.

Architecture contract · Workflow state and evidence contract

Governance and execution are separate responsibilities

How the Kit works

A human defines intent and approves decisions. A replaceable executor proposes and runs bounded actions through Kit contracts and checks. Git, CI and release services provide execution results. Evidence returns to repository state and successor handoffs.
On narrow screens, scroll the diagram horizontally. Logical responsibilities. A guard validates defined contracts; it does not prove general software correctness.
  1. Define intent. The maintainer owns requirements, risk acceptance and authorization.
  2. Inspect repository truth. The executor reads the project contract, architecture, current state and canonical handoff.
  3. Choose a bounded action. Manifest-backed commands and profiles expose checks, available operations and effects.
  4. Validate and execute. Focused Python modules implement the rules; CLI and GUI surfaces call the same governed operations. Git and CI remain separate systems.
  5. Record and hand off. Reports, source identities and generated successor packages preserve what happened and what remains open.

Authority and state

Repository contracts, profiles, policy packs and canonical state define the process. Doctor and related gates check configured contracts and known drift. The command manifest feeds CLI discovery, GUI grouping and public command views.

Adapters and integrations

CLI, GUI and transfer routes are interfaces. Focused core modules implement governed behavior; adapters connect Git, GitHub, CI and release services. Toolchain-specific behavior belongs in profiles or adapters.

Documentation and assurance

Documentation governance and bounded DPA checks address document authority, freshness and evidence. They do not establish arbitrary foreign-repository conformance or formal correctness of the product. PAA appears below as planning status, not a shipped proof engine.

Public interface, private implementation possible

Working with a local controller

A local controller can present work orders, transport a bounded request to an assistant, invoke allowed Kit commands and return their structured results. It can be private; the public Kit does not require publication of that controller's source.

The controller must preserve the command contract, action identity, approval boundaries, exit code and structured verdict. A failed or ambiguous result must remain visible. It must not invent a successful receipt, bypass a Kit block or become a competing governance authority.

File Transfer, Copy and Paste, Agent Direct and the experimental Kit GUI are the public interaction paths. A separate private controller is an integration example, not an additional public Kit product or a claim of universal plug-and-play compatibility.

A bounded interaction

  1. Human selects a task and its permissions.
  2. Controller sends repository context and a bounded request.
  3. Assistant proposes a change or next action.
  4. Kit validates the applicable command and repository state.
  5. Authorized execution produces evidence; blocked or failed states stop the flow.
  6. Controller displays the result and the next permitted step.

Choose an interaction path · Work-order contract

Observed results and their limits

How use changed the Kit

Self-hosting exercises the Kit's own repository workflow. Greenfield tests probe first adoption and first-cycle closeout. Brownfield work probes an existing project's constraints. Each can expose different defects; none alone establishes general reliability.

The current release notes below show repairs informed by external use, including context recovery, installation discovery and consumer CI where recorded. Test fixtures exercise defined scenarios; a mocked remote response is not a live remote retest. A DOI identifies a versioned release, not a quality certification.

Greenfield: installed release

agentic-project-kit==1.0.13 · 2026-09-16 · recorded_pass

Historical released-package first-cycle work/PR/CI/merge/handoff retest in a private external repository; not a retest of every later release.

Read the repository source

Brownfield: recorded maintenance

7 merged observations · latest: B1-COMM-SCI-20260831-007 · legacy seam count: 55 -> 44

Recorded maintenance observations in one familiar private repository; not an independent benchmark or general portability proof.

Read the repository source

Release notes, not a new retest

What changed in 1.1.0

Source status: recorded. Shipped changes recorded in the current release section.

  • Upgrade note for 1.0.x: transfer and typed work orders that run BOUNDED Kit commands, BOUNDED cockpit actions or unlisted commands now need the local --allow-unlisted flag; DESTRUCTIVE Kit commands, raw git/gh mutations and interpreters are refused in every order; transfer orders need a full 40-character expected_current_head bound to the commit they were written on; work-order run --execute, the next-turn.py slot and the current.sh slot report BLOCKED_RETIRED_LANE. Orders that ran under 1.0.25 can therefore stop and must be rewritten.
  • Report a real conflict from transfer rebase-on-upstream instead of CONFLICT: no, keep the in-progress rebase as evidence and block when the conflict state cannot be observed; read .git/config with repeated keys such as several remote.origin.fetch lines; let commands sync-entrypoints --execute refresh the DPA readiness command-manifest ACK, so a manifest change no longer needs a separate release-prepare step.
  • Add agentic-kit context report, which measures the files a successor is told to read (about 210,000 estimated tokens, 135,000 of them the command manifest), and agentic-kit context render --profile slice|planning|release|handoff, which renders a deterministic task packet of about 3,600 estimated tokens from the same authorities: current ACK, every execution-contract rule, manifest excerpts of the profile's commands, gates, open plan items and a checksummed path list for everything left out. Add the part 2 context benchmark harness with five tasks, deterministic success and ledger method checks, a no-LLM self-test, and its preregistration (docs/reports/context_budget_20261016/); the LLM runs await an owner decision.
  • Fix transfer remote-next and transfer continue crashing with a ScannerError on every transfer order that starts with the required COMMAND_MANIFEST_ACK line, so no order could complete remote-next; found by the new offline gate benchmark (docs/reports/gate_benchmark_20261016/), which detects 11 of 11 injected faults on main against 5 of 10 on 1.0.25.
  • Add agentic-kit audit-drift-signals, a report-only measurement of release-projection drift, refresh chains after product merges and Kit/consumer finding status, each with its denominator; agentic-kit ledger report now lists repeated failures by fingerprint and --write-finding-drafts writes local drafts that are never overwritten; the test suite no longer writes to the invocation ledger.
  • Add a local invocation ledger: every agentic-kit process start (and in-process calls an orchestrator reports) is recorded with command name, timing, return code, Kit version, branch and call-tree ids, never arguments, in the git-ignored .agentic/tmp/invocation-ledger/; on in the Kit repository, opt-in elsewhere, bounded retention, and a ledger failure never changes a command's result. agentic-kit ledger report summarises it read-only. agentic-kit doc-registry register gains --status, --review-policy and --summary, so new runbooks are registered without hand edits.
  • Retire the unrestricted work-order lanes: work-order run --execute, the next-turn.py fixed slot (next_turn_runner, GUI work-order run) and the current.sh agent command slot no longer execute code; they report BLOCKED_RETIRED_LANE and point to typed work orders, transfer orders and the planner executor (WOTB-04, WOTB-09). The commands are removed after a deprecation window.
  • Bind the freshness anchor of a transfer order to the commit it was written on: a full 40-character hash equal to HEAD for an uncommitted order or to the parent of the commit that last changed it, checked again after switch and pull on every transfer remote-next path including transfer continue, so the order that runs is the order that was validated (WOTB-07, WOTB-08). Orders with short anchors, or changed after anchoring, now stop as stale.

Read the repository source

Formal assurance: planning boundary

PAA: planned · review: review_required · P0: proposed

PAA is shown from the canonical plan. A planning status is not an implemented verification capability or a proof of software correctness.

Read the repository source

Read the sources for exact revisions, test methods and unresolved limits. Private targets are represented by public Kit reports; their source code and independent replication are not promised. No numerical maturity score or comparative benchmark is claimed.

Complementary roles and actual overlap

Where other tools fit

This is a dated orientation from official documentation, not a feature-completeness audit or benchmark. Products evolve; external descriptions do not update themselves from this repository. Sources and review dates remain visible, and the build makes no external network requests.

ToolCategoryDocumented focusRelationship to the KitSource and review date
GitHub Spec KitOpen-source specification/process toolkitStructured specifications, planning, implementation and convergence; extensible processes for coding agents.Overlaps in structured context and process guidance. Compare the concrete workflow and extension set you need; no blanket claim of absent governance.Official documentation
Reviewed 2026-10-12
pre-commitOpen-source hook frameworkInstalls and runs configured multi-language Git hooks.Useful alongside Kit gates. Hook execution and the Kit's repository-state, handoff and release contracts address different layers.Official documentation
Reviewed 2026-10-12
CursorCommercial coding-agent productAgent tool execution with documented run modes, approvals and sandboxing controls.Overlaps in execution safety. A coding executor can use Kit commands; no measured productivity, safety or cost ranking is claimed.Official documentation
Reviewed 2026-10-12
GitHub CopilotCommercial coding-agent productCoding assistance and agent workflows, including a cloud agent that can create branches, write code and open pull requests.Overlaps in development and PR workflows. Kit contracts can be an additional repository layer; compatibility with every product mode is not claimed.Official documentation
Reviewed 2026-10-12

The Kit's emphasis is a repository-owned operating contract across sessions and lifecycle steps. Agents supply coding assistance; hooks and CI run configured checks; specification tools structure intent. Select and combine tools for your requirements. We have no evidence that the Kit is categorically superior in safety, speed, drift or cost.

What remains your responsibility

Review requirements and changes, protect credentials, configure meaningful tests, authorize effects and maintain integration permissions. Fail-closed behavior can stop a workflow when evidence is missing; it is a diagnostic boundary, not an assurance that every permitted action is correct.

Adoption and controller UX remain work in progress. Additional files, review steps and handoff commits are real operational costs. There is no API-cost or CI-savings benchmark here, no universal multi-agent autonomy claim and no formal verification of arbitrary software.

Try a bounded first adoption · Inspect machine-checked claim bindings