Skip to content

v1.0.0 — Codex Hash Research Laboratory Whitepaper Series · 2026

Choose a tag to compare

View all tags
@ulissesflores ulissesflores released this 18 May 20:04
· 3 commits to main since this release
v1.0.0
fc691ed

v1.0.0 — Codex Hash Research Laboratory Whitepaper Series · 2026

First stable public release. Two independent technical whitepapers, a
pre-registered N=50 protocol with frozen per-trial dataset, a Claude
Code skill, and a deterministic adjudicator with cryptographic
provenance — all under a single release.

Publisher: Codex Hash Research Laboratory · São Paulo, Brazil
Author: Ulisses Flores · CTO & Chief Researcher
DOI: 10.5281/zenodo.20276632

Note on patches: a v1.0.1 follow-up to this release (a) embeds the
DOI inline in CITATION.cff and both papers' status blocks, (b) ships
the rebuilt PDFs as in-repo artefacts at paper/asp-preprint.pdf and
paper/iron-law-11.pdf, and (c) removes generation-only files
(Makefile, header.tex, redundant .gitkeeps) per the maintainer's
repo principle that artefato de geração ≠ produto gerado. The same
DOI's concept identifier auto-points to whichever is the most recent
version.

Headline empirical finding

On a pre-registered N=50 protocol against Claude Code 2.1.143 (Claude
Opus 4.7), claude -p returns exit code 0 on 30 of 50 graceful agent
refusals (60.0%; 95% Clopper–Pearson CI 46.5%–73.6%).

Safety-refusal scenarios produced 100% silent refusal of model-level
responses. Overall misclassification rate of "exit_zero ⇒ semantic
success": 88.0% (95% CI 75.7%–95.5%).

A shell wrapper of the form claude -p "$GOAL" && next_step will
silently mis-route the majority of agent refusals as task successes.
The six-line safe-parsing recipe in Whitepaper 2 §4 is mandatory for any
production pipeline wrapping the CLI.

The protocol's analysis plan, the 50 scenario prompts, the locked
refusal-phrase list, the random seed, and the falsification thresholds
were committed to git at commit 5c656f1 before any data collection
— eliminating HARKing and p-hacking concerns standard in clinical-trial-
style empirical ML.

What's in this release

Whitepapers (attached as binary assets)

  • asp-preprint.pdf — ASP: An Operational Pre-Mortem Skill for LLM
    Coding Agents — An Experience Report     (~5,300 words). Documents the
    13-phase Claude Code skill with 12 Iron Laws, integrating Mitchell-Russo-
    Pennington (1989) prospective hindsight, Klein (2007), Cemri et al.
    (2025) MAST 14-mode failure taxonomy, Erdogan et al. (2025) planner-
    executor separation, and the limits of intrinsic LLM self-correction
    (Huang et al. 2024; Tyen et al. 2024; Zheng et al. 2023).

  • iron-law-11.pdf — Graceful Refusals as Silent Successes: A
    Pre-Registered Protocol for Characterising claude -p Exit-Code
    Semantics     (~5,500 words including the empirical addendum). Pre-
    registered methodology + N=50 confusion matrix + Clopper-Pearson 95% CI

    • three constructive options for the Anthropic Claude Code team.

Per-trial dataset (attached as binary asset)

  • iron-law-11-trial-dataset-v1.0.0.zip — frozen per-trial dataset
    for the N=50 run (267 KB, 355 files). Each trial directory contains
    the verbatim prompt sent to claude -p, the captured exit code, the
    full JSON envelope returned, the extracted text response, and
    wall-clock timing. All artefacts SHA-256-hashed in the
    preregistration.json committed at the pre-registration commit
    5c656f1.

Companion source code

  • ASP skill — skills/anticipating-shadow-points/ — 13-phase
    pre-mortem-first planning protocol distributed as a Claude Code
    plugin. Three install paths (plugin marketplace, dev mode, standalone
    script).
  • Pre-registered protocol scripts — tests/iron-law-11/ — runnable
    scaffolding to reproduce the N=50 protocol on any Claude Code
    installation in ~10 minutes for ~$5 inference.
  • Python benchmark — benchmark/ — deterministic 4-layer
    adjudicator (exact / synonym / Jaccard / unmatched) with SHA-256
    Merkle-style hash chain over env + code + inputs + outputs +
    adjudication. 27/27 unit tests.

Cite this work

Flores, U. (2026). ASP — Anticipating Shadow Points (v1.0.0).
Codex Hash Research Laboratory Whitepaper Series.
https://doi.org/10.5281/zenodo.20276632

(See CITATION.cff for machine-readable format; GitHub's "Cite this
repository" button uses it automatically.)

The four primary methodological sources cited across both whitepapers
should be cited alongside ASP when discussing the methodology:

  • Mitchell, D. J., Russo, J. E., & Pennington, N. (1989). Back to the
    Future    . J. Behavioral Decision Making 2(1), 25–38.
  • Klein, G. (2007). Performing a Project Premortem. HBR 85(9).
  • Cemri, M., et al. (2025). Why Do Multi-Agent LLM Systems Fail?
    arXiv:2503.13657 (κ=0.88 on 1,600+ annotated traces).
  • Huang, J., et al. (2024). Large Language Models Cannot Self-Correct
    Reasoning Yet    . ICLR 2024 (arXiv:2310.01798).

The full bibliography (26 verified primary entries + 3 documentation
references) is in each whitepaper's References section.

License

  • Software (ASP skill, benchmark, protocol scripts, plugin
    manifests, all repository code): MIT.
  • Whitepaper text (PDFs and .md sources under paper/):
    CC BY 4.0.

When reusing methodology figures or significant passages, please cite
the work as above.

Reproducibility

The pre-registered protocol is reproducible end-to-end in ~10 minutes
for ~$5 inference. Anyone with claude on $PATH and a Claude Code
plan can verify (or refute) the headline finding:

git clone https://github.com/ulissesflores/anticipating-shadow-points
cd anticipating-shadow-points/tests/iron-law-11

# 1. Verify the pre-registration hash chain is intact
./scripts/verify-prereg.sh

# 2. Re-run the formal N=50 protocol against your installation
./scripts/run-protocol.sh

# 3. Analyse with the pre-committed analysis script
./scripts/analyze.py runs/<your-run-id>

To rebuild the whitepaper PDFs from the canonical .md sources, see
CONTRIBUTING.md § Rebuilding the whitepaper PDFs.

The benchmark package's deterministic adjudicator is reproducible
across machines (manifest hashes match):

cd benchmark
python -m venv .venv && .venv/bin/pip install -e ".[dev]"
.venv/bin/pytest                 # 27 passed

Pre-registration integrity

The Iron Law 11 protocol was pre-registered in git at commit 5c656f1
on 2026-05-18 before any data was collected. SHA-256 hashes of all 50
scenarios + the refusal-phrase list + the random seed are recorded in
tests/iron-law-11/preregistration.json. The verification script
tests/iron-law-11/scripts/verify-prereg.sh returned OK immediately
before formal dispatch and immediately after analysis. No deviations
from the pre-registration occurred.

The falsification thresholds (Whitepaper 2 §3.6) were committed before
data collection. The observed silent-refusal rate of 60.0% exceeds the
25% threshold, triggering the pre-registered recommendation: safe-
parsing recipe is mandatory; Anthropic notification recommended.

What is intentionally NOT in this repo

Per the maintainer's principle artefato de geração ≠ produto gerado,
the following live outside the repo:

  • Launch operations (social-media post drafts, posting calendar,
    engagement playbook, status tracker) live at ~/Developer/Publications/ anticipating-shadow-points/v1.0.0-launch/, designed for a separate
    agent (or the human author manually) to execute the rollout.
  • Build journals (advisor logs, demo template instantiations,
    intermediate closure reports, smoke-test outputs) live in git history
    but are not in-tree at this release.

Every byte in this release has a justification as a citable product.

Companion external resources

Acknowledgments

This research was prepared in explicit human-in-the-loop collaboration
with Claude (Anthropic, Opus 4.7), used as a drafting and verification
partner. Methodology decisions, empirical design, and finalisation were
performed by the human author. The work is published under his name
alone; see AUTHORS and docs/ARCHITECTURE.md Parts 5–6 for the
collaboration model.

The author thanks the maintainers of obra/superpowers, the contributors
of agentskills.io, and the Anthropic Claude Code team for the /goal
primitive and the --output-format json flag — the latter is exactly
the right primitive; this protocol exists because it exists.

Assets 5
Loading