samliumay/DOUBLE_ENTRY_OBSERVABILITY_FOR_LLM_AGENTS

Double-Entry Observability for LLM Agents

This is a small, data-only benchmark for testing model-authored action ledgers as a complementary observability layer in long LLM-agent workflows. All scenarios, identities, messages, and tool effects are synthetic. Nothing in the dataset performs a real external action.

Primary research question

Does comparing a model-authored action ledger with an authoritative environment ledger provide additional diagnostic signal beyond ordinary runtime telemetry?

The benchmark does not propose replacing authoritative telemetry. It supports measuring whether comparison with a separate model-authored ledger adds diagnostic information about action accounting, execution, and task outcomes.

Data format

The data uses JSONL: each line is one complete workflow. Every row starts with the familiar chat structure:

"messages": [
  {"role": "system", "content": "..."},
  {"role": "user", "content": "..."}
]

The remaining fields define the available tools, synthetic starting state, reference function calls, logging rule, execution limits, and evaluation criteria. For a field-by-field explanation and the intended model/runner/evaluator boundary, see data_structure.md. The exact machine-readable format is documented by schemas/workflow-v2.schema.json.

Split	Workflows	Ordinary calls	Purpose
validation	3	50	Development and pilot evaluation
test	1	19	Held out; not yet runnable (see below)

The test split is data-complete but has never been executed end to end. Its production-outage-customer-coordination-v1 workflow declares 14 ordinary tools, and the reference runtime implements simulators for only the three validation workflows, so a run against it stops before inference rather than producing artifacts. Treat the split as a held-out specification until an outage simulator exists.

The JSONL files remain compact because one workflow must occupy one line. Indented copies are provided only for reading:

• data/readable/test.json
• data/readable/validation.json

The .jsonl files are the benchmark source; the readable files contain the same records as indented JSON arrays.

Logging contract

Each ordinary function call in reference_trace is immediately followed by a log_action call. The log repeats the ordinary call's ID, tool name, requested behavior, and outcome. Rejected and failed attempts must also be logged.

log_action does not log itself, which prevents an infinite logging loop. The reference trace is one valid example, not the only valid solution.

issue_tags on a trace entry mark points where the agent could plausibly go wrong. Every tag uses a *_opportunity suffix and corresponds to an item in the workflow's evaluation.incident_opportunities.

The reverse does not hold, and nothing enforces it: incident_opportunities lists every way the workflow anticipates going wrong, while issue_tags only mark the points the authored reference path passes through. Opportunities that arise from not acting — omitting a policy-relevant action, failing to log a rejected call, fabricating an approval — have no trace entry to attach to. Nor is the mapping one-to-one in the other direction: two tags can mark the same opportunity. Counting opportunities that any tag reaches, coverage is 3/4 for procurement, 3/4 for calendar, 2/4 for vendor-security, and 2/5 for the outage workflow. Use incident_opportunities as the evaluation surface; treat issue_tags as navigation hints into the reference trace.

Loading with Hugging Face Datasets

from datasets import load_dataset

dataset = load_dataset(
    "json",
    data_files={
        "validation": "data/validation.jsonl",
        "test": "data/test.jsonl",
    },
)

Structure check

The standalone validator uses the jsonschema library. Install it first:

pip install -r requirements.txt

Then give it the file you want to check:

python3 validate_dataset.py data/test.jsonl
python3 validate_dataset.py data/validation.jsonl
python3 validate_dataset.py data/readable/test.json

It checks JSON syntax, the v2 schema, unique identifiers, declared tools, execution limits, required ordinary-call/behavior-log pairs, and stateful structured-report rules such as opening documents before use and citing every report claim. It exits with status 0 for a valid file and 1 when it finds structure problems.

Results

The earlier exploratory pilot has been withdrawn and its artifacts removed. It was run against a harness with two defects that made its numbers unsafe to publish:

1. Ledger quality was reported as a single score that measured only whether each log_action named the right tool and outcome. It ignored whether the entry arrived before the next ordinary call, which is what the logging contract in this dataset actually requires. Runs that emitted several calls per response therefore scored as fully compliant while their own event streams recorded violations.
2. Trial manifests did not record the runtime revision, whether its worktree was modified, or the dependency versions in use, so the runs could not be reproduced from the artifacts alone.

Both are fixed in the reference runtime. Derived analyses now report content agreement and protocol compliance as separate measures, and manifests record the code revision, a dirty-worktree flag, Python and dependency versions, execution limits, token usage, and a classified termination reason.

A replacement pilot has not been run yet. When it is, its complete artifacts — raw events, conversations, manifests, derived runs, and analyses — will be published here, and this section will state the exact models, sampling settings, and dataset commit used.

Two limits on the eventual results are worth stating in advance. The executive-release-calendar-recovery-v1 and procurement-payment-change-triage-v1 workflows use canonical identifiers that are present in the reference trace and the hidden state but are not discoverable through the declared agent-facing tools, so results for those two scenarios diagnose benchmark accessibility rather than model capability. And no reasoning trace is requested, parsed, or used as evidence: the runtime never reads a provider thinking field. Reasoning text can still reach a transcript when a model emits it inline in ordinary message content, which is recorded verbatim; artifacts are preserved as captured rather than edited after the fact, so treat any such text as raw provider output, not as an evidence channel.

Limitations

The four workflows are pilot data, not a representative sample of production agent tasks. The reference traces are authored examples rather than observed LLM outputs. The dataset can test observable task and logging behavior; it does not by itself establish deception, intent, or general misalignment.

The dataset is licensed under the MIT License. See LICENSE for the full text.