AIWorkHubSemantic edit: workers change hash-verified line ranges, never rewrite whole files.
Open source · Local first · Repository native
An AI manager that runs Claude Code, Codex and Copilot as its workers.
It splits a large project into work cards, sends each card to the cheapest model that can do it, reviews every change against tests before it lands in your tree — and it is building AIWorkHub itself.
Create a bounded task, launch a model worker, inspect its evidence and accept or rework it.
Proof, from this repository's own history
1,984commits since 2026-07-20, written through its own task loop
347work cards accepted into its own tree
651times a worker's change was sent back with code-level findings
621independent reviewer passes
620test files, about 262k lines of Python
Review loop: mechanical gates and tests run first, then an independent reviewer reads the code; the manager accepts, returns with findings, or blocks — the same turn.
The whole system
From a durable observation to a verified release.
AIWorkHub connects repository authority, durable context, model routing, isolated execution and independent assurance in one control loop. Solid capabilities are live today; amber work is being hardened; dashed violet capabilities are the next planned layer.
Operating foundations
NeedFix intake, Roadmap outcomes, Task DAG, collision guard, Source Graph, Session Manager, AI Memory, KB, Context Graph, provider catalog, outcome-aware ranking, preflight, retained worktrees, semantic edits, MCP tool bridge, validation sandbox, independent review, sealed receipts, provider-free replay, checkpoints, atomic promotion and rollback.
Current closure wave
Reviewer MCP response delivery, exact liveness without model wall-clock kills, finalizer leases, validation environment isolation, offline-stage recovery, Windows/Linux parity, Source Graph refresh truth, bounded storage retention and automatic NeedFix lifecycle reconciliation.
Next system layer
NeedFix auto-close and TTL purge, provider/model enable-disable controls, CPU-aware parallelism, durable refresh job IDs, cross-platform finalizer completion, Rust semantic coverage, richer JSON evidence visualization and quality-calibrated release automation.
The engineering loop
Delegate work without giving up authority.
Every repository owns its task state, indexes, memories, callbacks and audit trail. Models work in bounded scopes; the manager accepts changes only after evidence is checked.
Plan a dependency-aware task
Choose an available model route
Work in an isolated scope
Collect diff, tests and receipts
Accept, reject or rework
AIWorkHub managing its own repository
Built from a real engineering bottleneck
Your coding agents can write code. Who keeps the work coherent?
AIWorkHub began while managing long-running, multi-model development: decisions disappeared after context compaction, repositories were scanned repeatedly, parallel changes collided, session knowledge was lost and a model's “done” still required manual proof.
I did not build AIWorkHub to demonstrate multi-agent orchestration. I built it because I needed several coding models to work on real repositories without losing decisions, colliding with each other or asking me to trust unverified completion claims.
Task DAGs, Source Graph, Manager Context Graph, durable memory, callbacks, isolated workers and evidence receipts are direct answers to those failures—not a collection of unrelated agent-demo features.
Product surfaces
Built for real multi-agent coding workflows.
Agent orchestration
Repository-bound tasks, dependency planning, model routing, bounded execution and callback delivery.
Source Graph
Structural code context through focused, sliced, impact, trace and bundle queries instead of repeated broad scans.
Durable context
Separate Session Manager, AI Memory, knowledge base and manager-only Context Graph authorities.
Evidence-based review
Review diffs, tests, logs, artifacts, tool-use receipts and approval history—not model self-reports.
Multi-agent planning
Parallelize independent cards while dependency and write-scope collision checks preserve task truth.
VS Code and Remote SSH
Use the editor models and authenticated CLIs you already have across Windows, macOS, Linux and Remote SSH.
Model portfolio economics
Use frontier models for judgment—not for every unit of work.
AIWorkHub can reserve premium models for architecture, difficult reasoning and independent review while routing bounded research, tests, focused edits and mechanical throughput to lower-cost capable models. Source Graph and semantic edits reduce avoidable tokens on every route; model routing then reduces how many of the remaining tokens are bought from the most expensive model.
| Layer | System action | Economic effect |
|---|---|---|
| Token efficiency | Bounded graph context, bounded reads and replacement-only edits | Less unnecessary input and code-output payload |
| Model-mix efficiency | Match task difficulty to capability, readiness, observed quality and known cost | Fewer premium-model tokens for work an economical route can complete |
| Attempt efficiency | Preserve exact failure evidence and issue bounded residual rework | Fewer blind retries and less repeated context/work |
| Deterministic offload | Apply hash-bound edits and run validation locally | No model spend for operations that do not require model judgment |
The mechanism is shipped; the public system-wide ROI is not yet claimed. In the measured Claude cohort, Opus used 19% of tokens but 42.9% of known cost. AIWorkHub counts routing as a saving only after the cheaper route preserves validation and manager-accepted quality.
The product category
Control plane above the agents you already use.
AIWorkHub does not compete with the models whose work it coordinates. Its real alternative is manual multi-chat orchestration or a custom stack of task boards, worktrees, context stores, scripts and review glue.
| Layer | Examples | Role |
|---|---|---|
| Repository control plane | AIWorkHub | Task authority, routing, context, isolation, evidence, callbacks, review and economics |
| Supported workforce | Codex, Claude, Copilot-hosted models, DeepSeek, GLM | Execution routes coordinated by AIWorkHub—not competitors |
| Adjacent context/edit tools | Graphify, Serena and similar toolkits | Complementary graph, retrieval or semantic capabilities |
| Standalone agent clients | Aider, Cline and similar products | Alternative execution experiences, not the same control-plane layer |
| Actual alternative | Manual coordination or custom in-house glue | Copy/paste context, hand-managed worktrees, retries and review state |
System evidence
Measure benefits, failures and unknowns.
AIWorkHub distinguishes structural bytes, provider tokens, task outcomes, manager decisions, callback durability and missing evidence. The full benchmark matrix publishes favorable and negative results with their exact populations.
7/7current gated tasks used live Source Graph evidence
Not claim-eligiblehistorical capped A/B observation; pair 1 used mismatched 20k/200k token ceilings
0dead letters across 271 callback events
−29.329%same-evidence v2 context-envelope fixture versus legacy v1
The historical capped A/B observation recorded 27.5% fewer total tokens, but pair 1 used mismatched 20k/200k token ceilings. It is not eligible for a causal or product-savings claim; an uncapped matched rerun is required. The envelope result is deterministic structural evidence from one same-evidence fixture; the old 0.8.81 fleet expanded 20.0% and v2 still needs an equivalent live remeasurement. Tool-use outcome differences are observational, and system-wide cost savings remain unmeasured.