Hypothesize. Simulate. Falsify.
Simjecture is an evidence-governed autonomous experimentation and falsification system for computational science. It tackles long-horizon problems inside a human-defined problem contract where finding a useful law or counterexample requires a difficult search, but a proposed result can be checked much more cheaply. The model grows and tests a tree-like graph of competing hypotheses, writes its own experiments and diagnostics, and searches deliberately for the simplest result that survives independent verification. The harness controls what may count as evidence.
Research preview: version 0.1 validates the infrastructure and records real autonomous simulation campaigns. It does not claim to solve arbitrary scientific prose, establish truth about nature from one simulator, or replace independent scientific review.
The project began as an autonomous conjecture-solving harness for computational plasma physics. The same claim ledger, sandbox, commissioning rules, and capability framework are now ready to extend to other simulation-gated fields that have a sharp question and a checkable instrument. Version 0.1 records both the origin domain and that generalization.
Scientific problems are not uniformly difficult. A candidate may be buried in a vast space of mechanisms, representations, and parameter regimes, while the decisive properties of that candidate are comparatively inexpensive to test. This discovery–verification asymmetry is a difficulty inversion: a problem that is high-hanging for human intuition may be low-hanging for a machine that can sustain search, write code, change representation, and reject failed ideas without fatigue.
An AI low-hanging-fruit problem is therefore not a trivial problem. It is a scientifically valuable problem with a favorable machine difficulty profile:
- a sharply defined question and evidence standard;
- a large but structured space that benefits from persistent search;
- a compact possible answer, such as a matched counterexample, scaling law, phase boundary, missing variable, or impossibility statement; and
- an affordable path to checking that answer without trusting model prose.
The project tries to exploit this structure in computational science, where verification is graded, stochastic, model-dependent, and numerically fallible. A simulator producing a plausible figure is not a verifier; admissibility, convergence, uncertainty, independent diagnostics, and fresh confirmation all matter.
The human supplies an immutable root proposition and the scientific boundaries. The agent owns the route through a changing frontier of daughter hypotheses: competing explanations, measurable predictions, discriminating tests, instrument checks, specializations, and repairs. Although “hypothesis tree” is the intuitive picture, the durable structure is a typed graph because one node may depend on or test several others.
root proposition
├── alternative explanation A
├── alternative explanation B
├── predicted signature / discriminating test
├── instrument and numerical validity claims
└── repaired or narrower proposition after a failure
Each experiment should remove uncertainty from this graph, not merely add another point to a scan. A failed diagnostic challenges the instrument rather than the physics. A valid counterexample may reject a parent hypothesis, but it only motivates a repaired daughter; that daughter needs new evidence of its own. Falsified branches remain useful recorded knowledge rather than being rewritten into a success story.
The default scientific posture is destructive: ask what cheapest valid calculation could break the active claim. Useful witnesses include two matched cases with different outcomes, a bound or invariance violation, a monotonicity reversal, a threshold crossing, or a path-dependence pair. A candidate witness has asymmetric leverage: one verified witness can reject a universal sufficiency or bound claim even when confirming that claim everywhere would be impossible. It must still pass numerical and physical validity gates, survive fresh held-out tests, and face deliberate attempts to explain it away or falsify the resulting law.
The primary output is therefore not generated prose. It is an independently inspectable discovery package: the hypothesis graph, compact discovery object, exact commands, source hashes, simulator outputs, diagnostics, uncertainty and validation results, failed alternatives, falsification attempts, and scoped claim dispositions. An honest bounded null result is also acceptable.
human-defined question + root hypothesis + evidence standard
│
▼
search the typed hypothesis frontier
│
▼
choose a discriminating intervention
│
▼
agent-authored experiment, diagnostic, or simulation
│
▼
commissioning + physical and numerical validity gates
│ │
invalid run valid evidence
│ │
recorded non-evidence support / counterexample /
and instrument repair unresolved result
│ │
└──────────┬──────────────┘
▼
update the hypothesis graph
│
▼
fresh confirmation + adversarial attack
│
▼
verifiable discovery package
The agent owns scientific choices within the supplied scope; the harness owns evidence eligibility. It does not hard-code a plasma model, diagnostic sequence, or daughter-hypothesis tree, even though plasma was the first domain. It does require prospective evidence contracts, commissioned instruments, immutable provenance, and guarded claim closure so that a persuasive explanation cannot substitute for a valid result.
The fastest way to see Simjecture is to replay the recorded Gray–Scott campaign. It is a real 23.8-minute autonomous run, preserved with its hypothesis tree, transcript, agent-written programs, numerical evidence, and provenance. Replay is read-only: it makes no model calls and starts no simulations.
git clone https://github.com/tomzhu0225/simjecture.git
cd simjecture
uv sync --frozen --extra tui
uv run python demos/gray_scott_counterexample/verify_record.py
uv run simjecture tui demos/gray_scott_counterexample/recordInside the dashboard, select hypotheses to inspect their linked evidence and
validation claims; press v for the complete typed audit ledger. For a
non-interactive summary instead, run:
uv run simjecture status demos/gray_scott_counterexample/recordThe dashboard is a human-readable projection. The files in the recorded run remain the authoritative scientific record.
Requirements:
- Linux with Python 3.11 or newer
- uv
- Bubblewrap (
bwrap) for the isolated natural-language MVP - an API key for an enabled model provider
git clone https://github.com/tomzhu0225/simjecture.git
cd simjecture
uv sync --frozen
uv run simjecture install core
export DEEPSEEK_API_KEY='your-process-local-key'
uv run simjecture mvp \
--hypothesis "A charged particle's magnetic moment is conserved when the magnetic field varies slowly across its gyro-orbit." \
--output artifacts/magnetic-mirror-mvpconjecture-solver and acs remain compatibility aliases. The internal Python
package remains conjecture_solver, preserving the implementation namespace
used by existing capabilities and integrations. Never place a real provider key
in a tracked file, prompt, run workspace, or command transcript.
An operator may add an instrument preference without changing the root hypothesis:
uv run simjecture mvp \
--hypothesis-file hypothesis.txt \
--instruction "Use the installed WarpX capability." \
--output artifacts/campaignFor expensive problems, --guided-commission can provide a known-runnable,
operator-validated starting program. Guided files remain non-evidentiary until
the agent prospectively contracts and executes fresh evidence.
Inspect a durable run without starting another campaign. These commands do not require the optional terminal extra and do not invent a scientific completion percentage:
uv run simjecture status artifacts/magnetic-mirror-mvp
uv run simjecture watch artifacts/magnetic-mirror-mvpA missing mvp_report.json is reported as incomplete, not as running. Ctrl-C
on watch stops the viewer only. pause requests a stop at the next action
boundary; resume repeats a self-contained stored launch contract without
resetting its cumulative wall-time budget. External writable or configuration
paths require the operator to repeat the reviewed original command.
The optional dashboard is a projection of the same artifacts:
uv sync --extra tui
uv run simjecture tui
uv run simjecture tui artifacts/magnetic-mirror-mvpIts primary view separates the scientific hypothesis tree from instrument,
diagnostic, and control claims attached to the selected hypothesis. Press v
for the complete typed audit ledger; no claim or provenance record is hidden by
the human-first projection.
- Network-isolated writable agent workspace with no provider credentials.
- Typed, single-action model protocol and bounded tool outputs.
- Prospective evidence contracts with machine-checkable JSON assertions.
- Workbench artifacts permanently separated from evidence-stage artifacts.
- Source- and command-bound capability commissioning.
- Exact artifact provenance, hashes, seeds, runtimes, and claim linkage.
- Durable transcripts, crash recovery, replay, cancellation, and idempotency.
- Numerical failure remains non-evidence.
- Immutable root-claim and guarded scientific closure semantics.
- Soft startup literature search when public retrieval is available.
| Evaluation | Status | What it establishes |
|---|---|---|
| Matched-moment kinetic sufficiency | Qualified planted counterexample | End-to-end analytic, independent PIC, and WarpX verification in the plasma origin domain |
| Magnetic mirror and nonlinear Landau MVPs | Completed plasma research runs | Natural-language operation on origin-domain problems |
| Gray–Scott MVP | Completed research run | Same harness on a non-plasma, agent-authored instrument |
| Collisionless GEM held-out campaign 0004 | 12 fresh CUDA runs completed | Guided autonomous commissioning, execution, analysis, and guarded claim handling |
Run 0004 produced a finite-sample point-estimate falsification of its operational child claim, while its three-seed uncertainty interval still crossed the proposed population threshold. The immutable root remained open. This is documented as a real autonomous run and an example of why machine provenance does not remove the need for independent scientific audit.
Version 0.1 ships that harness. The next step is to use it: apply the same claim ledger, sandbox, commissioning rules, and capability framework to more simulation-gated problems, and hunt independently confirmed new results — a compact law, a matched counterexample, or a scoped impossibility — in the origin domain and beyond.
The repository includes two inspectable release demonstrations rather than only descriptions of past runs.
Starting from a natural-language Gray–Scott hypothesis and no campaign instruction, the agent rejected an unsuitable installed capability, authored its own numerical instrument, proposed and tested a daughter hypothesis, and found a finite-domain counterexample in 23.8 minutes.
The package contains the exact input, complete transcript, portable hypothesis
ledger, prospective evidence contracts, final report, source and command
provenance, all agent-written programs, numerical arrays, integrity checker,
and a read-only TUI replay. See
demos/gray_scott_counterexample/.
Starting from a validated, explicitly non-evidentiary GEM CUDA instrument, the agent designed a held-out confirmation campaign, commissioned its simulator and analyzer, and executed 12 fresh fully kinetic simulations across three paired seeds, two temperature ratios, and two particle counts. Each run used a 256×128 grid, four kinetic populations, 4,623 explicit steps, and 26 openPMD field states.
The 16-PPC endpoint ratio was 1.0122, with a paired-bootstrap 95% interval of
[0.8232, 1.4374], against a proposed threshold of 1.25. The frozen
finite-sample rule falsified the operational daughter, while the population
root remained open because the three-seed interval crossed the threshold. The
package preserves the exact autonomous transcript and claim ledger, all 12 run
summaries, hash-addressed provenance for 482 original artifacts, and
representative final fields. See
demos/collisionless_gem_reconnection/.
WarpX is the first simulation skill and executable capability, not an architectural dependency. The versioned skill covers PICMI interfaces, explicit and implicit time integration, openPMD diagnostics, numerical risks, CPU/GPU deployment, and resource scaling. Local runtime installations remain ignored by Git and are mounted read-only into the sandbox.
Install and verify the release-pinned CPU capability with:
uv run simjecture install warpx-cpu
uv run simjecture doctor --profile warpx-cpuCUDA remains an explicit hardware-specific profile whose audited WarpX source checkout must be supplied by the operator. The installer validates its pinned revision before invoking the existing build and openPMD probe.
See skills/warpx/SKILL.md and the deployment reference
in skills/warpx/references/local-cuda-deployment.md.
The curated documentation uses Sphinx, MyST Markdown, and the PyData Sphinx Theme.
uv sync --group docs
uv run --group docs sphinx-build -W --keep-going -b html docs docs/_build/htmlStart with docs/index.md. The accompanying manuscript is
maintained separately until its archival release.
uv sync --all-groups --extra tui
uv run ruff check .
uv run pytest
uv run simjecture schemas --output schemas --checkSee CONTRIBUTING.md, SECURITY.md, and THIRD_PARTY_NOTICES.md.
src/conjecture_solver/ core models, ledgers, orchestration, sandbox, and CLI
skills/ versioned model-readable scientific capabilities
capabilities/ installed executable capability manifests
demos/ bounded demonstrations and operator examples
schemas/ committed public JSON Schemas
scripts/ qualification, deployment, audit, and maintenance tools
tests/ deterministic and integration regression coverage
docs/ curated documentation
Citation metadata is provided in CITATION.cff. Version 0.1.0 is archived at doi:10.5281/zenodo.21945749; the concept DOI resolves to the release series. Cite the exact software version and Git commit used for a result.
Copyright 2026 Bowen Zhu and contributors. Licensed under the Apache License 2.0.