Relic: From Multi-Agent Collaboration to Persistent Organizational Capability
Hongyi Du, Tianyi Zhang, Weijia Zhang, Yi Yang, Haofei Yu, Kunlun Zhu, Tianxiang Dai, Shang Jiang, Zhelun Gao, Jiaxin Pei, Shang Zhu, Jiaxuan You
cs.AI, cs.SE
2026-09-27
Relic turns collaboration failures into executable protocols: complete-contract delivery 14.06% to 19.76% over 360 runs; after turnover, bindings beat text-only rules by 6.5 pp.
When several coding agents share one repository, breakage usually hits interfaces and integration. One member changes a return type; another keeps writing the client against the old signature; tests pass on a stale commit. ChatDev, MetaGPT, and AutoGen coordinate whoever is present through roles and talk. A conversation can settle that episode. It does not automatically bind the next occupant of the same role. Engineering notes from Anthropic describe fresh coding sessions that start with no prior memory. Prime Intellect reported GPT-5.6 Sol suspecting subagent edits to shared code and locking advisors to read-only.
Reusable skill libraries can keep a testing procedure around, and Voyager-style executable skills can run a suite. They do not assign an independent reviewer, and they do not require evidence on the current commit before merge. If the agreement lives in chat, it only governs the people who were there.
Relic splits state into three stores: member-local memory and workspaces, shared code and tasks, and organization-owned protocols. The last store follows the role, not the person. A protocol names its trigger, responsible roles, required evidence, execution consequences, and how it is revised or retired. Members propose rules from visible friction. The system checks that the proposal is grounded and can attach to supported actions. After approval, the spec compiles into a runtime binding that feeds action scoring and execution checks.
A Structured Decision Layer (SDL) scores candidates with 32 fixed features covering progress, role fit, coordination, repository health, and protocol obligations. Protocol content changes the inputs; the scorer stays frozen. The language model writes code or messages when the chosen action needs them. Routine selection does not call the model. Governance is semi-automatic: at least two supporters, two distinct approvers, a three-step minimum review, and an adoption score of 0.6 or higher. Stuck proposals can get bounded deadlock recovery after 24 steps. Model weights and handler code never update during a run. Only the rules do.
B0 is a reflective single agent. B1 is an eight-member long-horizon team. B2 adds SDL and member learning with the protocol lifecycle off. B3 is Relic. Subtracting B2 from B3 isolates the institutional layer.
The main study runs ten software workloads on GPT-5.6 Terra, Claude Opus 4.6, and DeepSeek-V4-Flash, three seeds each, 360 controlled runs, 336 scheduling steps. Five workloads build from a starter skeleton; five repair or extend frozen upstream versions. A complete contract means every case in a related group passes on mainline.
| Condition | Complete contracts | Held-out cases | Exposed cases | Confirmed seeded issues |
| B2 (SDL, no protocol lifecycle) | 14.06% | 9.57% | 19.31% | 17.91% |
| Relic (B3) | 19.76% | 17.28% | 25.89% | 24.87% |
| Delta | +5.71 pp | +7.72 pp | +6.58 pp | +6.96 pp |
Point estimates are positive for all four endpoints in every model stratum. Relic spends 7.259M tokens per run against B2's 4.274M. Tokens per confirmed issue, paired over 20 shared model-workload blocks, differ by -0.448M, with an interval that crosses zero. Cutting Relic at B2's realized spend still shows gains on all four endpoints, +7.45 pp on complete contracts. The unstructured eight-member team B1 burns about 45.2M tokens per run, an order of magnitude more than Relic.
A 60-run Terra plus Opus census recorded 497 autonomous proposals, 405 ever adopted, and 280 lineages that met the sustained-use bar, 32 of them with third-party execution tied to evaluator outcomes. Review/merge, release engineering, and evidence governance make up 87.1% of formed lineages. Relic moves 36% of accepted work onto mainline versus 32% for B2, and merges 50% of PRs versus 44%. The single agent accepts the most patches (86% versus Relic's 81%) and posts the fewest complete contracts. Local green tests do not equal delivery.
Two controls isolate executability. On 30 matched Claude Opus 4.6 runs, B3-text keeps proposal, governance, and readable rules but drops bindings; complete contracts fall from 22.20% to 15.03%. With fresh members and a frozen rule package, behavioral correctness is 25.4% with nothing inherited, 34.6% with the same rules as prose, and 41.2% with executable bindings, 6.5 pp above text.
On CooperBench, after the same broken-pair exclusions, Relic reaches 367/477 (76.9%) against 282/477 (59.1%) for the strongest released peer system and 354/477 (74.2%) for the strongest hierarchical Team. On a fixed 48-pair Claude Opus 4.6 subset, official Peer drops from Solo's 26/48 to 13/48; Relic is 29/48. On 25 ProgramBench tasks, a frozen pack of six executable plus three advisory rules, with SDL off, lifts mini-SWE-agent from 64.164% to 70.916% mean behavioral pass.
In one traced case (miniblobstorev1, seed 1401, GPT-5.6 Terra), an interface-review rule is proposed at step 12, adopted at 21, then enforced 211 times across 12 PRs. Matched B1 accepts 168 patches and merges two PRs; Relic accepts 118 and merges 76, with 28/35 cases versus 0/35. The paper states that 65 of 76 merges were never blocked by this rule, so its causal share is not isolated.
For teams running multi-agent coding, this turns organizational capability into a transferable object: the rule outlives the member, and the obligation follows the role. Readable rules already help. Binding them into the runtime is where the extra points come from. Protocols can be learned online, or a frozen pack can be attached to another harness, which is what ProgramBench tests.
The lift is real and modest. Complete-contract delivery is still about one in five. Versus hierarchical Team on CooperBench the gap is 2.7 pp. This is an institutional layer for long-horizon collaboration, not a stronger coding model.
The authors restrict evaluation to software production and list cross-domain transfer, selective forgetting, rule-quality diagnosis, other decision layers, and human-organization interaction as open. SDL weights are hand-set. The lifecycle edits rule text; the scorer does not learn.
The Exec-minus-Text 95% interval is [0.7, 15.6], almost touching zero at the low end. Only 32 of 280 sustained lineages carry strong evaluator-linked evidence. CooperBench's 76.9% is after dropping broken pairs; the Team gap is small. For the five from-scratch workloads, specs, references, and tests were written by a language model then frozen; kinship between generator and evaluator is not ablated. B1 burns about 45.2M tokens per run, so adding people can be extremely expensive. Relic also spends about 3M extra tokens per run versus B2. A matched-spend cut still shows a gain. That does not mean a production team will pay the governance tax.