# 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.

## 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](/comparisons/contract-lifecycle/).
- Template library and core packages:
  [github.com/accordproject](https://github.com/accordproject/cicero-template-library)
- Ergo language paper:
  [arxiv.org/pdf/2112.07064v1](https://arxiv.org/pdf/2112.07064v1)