Accord / Cicero

In short: Accord executes a contract clause as text plus data plus logic; Arxo models the obligation the clause creates. This page is for readers who ship computable contracts and want the precise seams: time, money representation, and what counts as an explanation.

Key differencesChoosing and combiningEvidence & limitations

What Accord is for

The Accord Project’s Cicero stack digitizes a contract clause end to end: natural-language template text with variables, a versioned typed data model, and executable logic, invoked with data, a request, and optional state, returning an answer plus outgoing events. Its strengths are the text-data-logic binding (the template generates text from data and back), importable versioned models, per-template executable tests as an independent check, a server wrapper, and a playground for prototyping.

Where it meets Arxo

One late-delivery clause — penalty formula with a cap, a strict termination threshold, bilateral force majeure, refusals — executes on both sides with the same observable answers: penalty, termination right, release, and event content. The protocol changed between the two pinned template editions (stateful execution versus a stateless trigger), so the edition is part of every claim.

Key differences

• Evaluation time is wall-clock. The studied template reads the current date inside its logic, so identical requests drift over time. Arxo takes time as an explicit input. The contract absorbs the drift with a tolerance — a comparison device, not an engine fix.
• Money is binary float. Amounts ride double-precision values with no conversions; the template’s own recorded test expects a long float tail. Arxo money is exact decimal. Cent-level comparison needs an explicit epsilon, stated before the run.
• Declared but unused model fields stay non-comparable. A fractional part declared in the data model but read by neither text nor logic marks a text-versus-code seam — recorded with its cause, never scored as a failure.
• Explanation is answer plus event. There is no proof graph and no cross-clause conflict composition; the outgoing event carries a human description. Against Arxo’s derivation graph that is a real asymmetry on this task.

A concrete scenario

The prepared experiment checks answer parity on fourteen clause cases — the force-majeure conjunction, the penalty formula with its cap, the strict termination threshold, refusals, event content — plus four edits covering money representation, threshold conversion, parameters, and the model-and-protocol change. The older edition’s answers come from its recorded tests, not from execution, and are labeled as such.

Choosing and combining

Choose Accord when the deliverable is a computable contracting artifact: template text the parties read, data their systems fill, logic that runs on request. Look to Arxo when the clause needs conflict handling across sources, dated editions, or a derivation a reviewer can replay without the runtime. Combined, Accord can execute the clause while Arxo holds the normative frame — same observable answers, reconciled where time and money representation force tolerances.

Evidence and open questions

• Sources checked: September 2026, re-verified (package registry, raw template files, hashes of all inputs matching).
• Studied profile: the Cicero core and template engine at pinned versions, with the late-delivery template in two pinned editions, old and new logic languages.
• Basis: confirmed by documentation plus a prepared protocol; comparative run not performed. No parity or timing is claimed.
• Open: fractional-period and business-day readings that must stay non-comparable, and any execution beyond the recorded tests.

Sources and reproducible materials

• Shared scenario: One contract, four systems.
• Template library and core packages: github.com/accordproject
• Ergo language paper: arxiv.org/pdf/2112.07064v1