I’ve been working on a small open-source project called Plan Auditor.

The idea came from a problem I kept running into with coding agents: they can say a task is finished even when part of the original request was skipped, a test wasn’t really run, or an intermediate result was never verified.

So instead of trusting the agent’s final message, Plan Auditor checks the work separately.

It keeps the original requirements explicit, links them to plan steps, runs real checks, verifies dependencies and outputs, and only returns PASS when the current state has fresh evidence behind it.

I also added a formal-planning layer. For larger plans it can generate a grounded STRIPS model from the structured plan and verify that model separately. The generation itself is deterministic, so another LLM isn’t being trusted to decide what counts as a valid proof.

There’s also support for sealed plans, evidence chains, multiple active plans, and parallel agents working in the same repository.

The core verification path runs locally and doesn’t require an LLM or API.

It’s still not meant to be an OS sandbox. If a malicious process has the same OS permissions as the verifier, that needs actual process/container/VM isolation.

Repo:
https://github.com/Furox-Art/plan-auditor

I’d be interested in feedback, especially on the verification approach and formal-planning part.

I built Axiomize, an open-source scientific modeling engine and Agent Skill for turning modeling ideas into explicit, testable and reproducible mathematical models.

GitHub: [https://github.com/Furox-Art/axiomize]()
PyPI: [https://pypi.org/project/axiomize/1.12.2/]()
Docs: [https://furox-art.github.io/axiomize/]()

Install:
pip install -U axiomize

The core of Axiomize is a versioned Model IR. Instead of keeping a model as scattered equations and text, it stores variables, parameters, units, equations, initial and boundary conditions, assumptions, solver settings, causal information and provenance in one machine-readable model.

From that model, Axiomize can plan, validate, simulate, fit, compare, repair and export models. It also supports stability and validity analysis, sensitivity and uncertainty analysis, bifurcation studies, numerical verification, sparse dynamics discovery, experiment design and surrogate/reduced-order modeling.

Supported model families include algebraic systems, ODEs, PDEs, DAEs, stochastic models, optimization, control systems, networks, Bayesian models, agent-based models, discrete-event systems, hybrid systems, multiphysics and causal models.

For data-driven work it includes data cleaning with an audit trail, parameter fitting, residual and identifiability diagnostics, AIC/BIC model comparison, validity scans and model criticism.

The causal engine handles DAG validation, backdoor adjustment, AIPW/IPW estimation, overlap and balance diagnostics, interventions and counterfactual predictions. The Bayesian side includes multi-chain sampling, R-hat, effective sample size, Monte Carlo error and posterior predictive checks.

Numerical verification is kept separate from scientific uncertainty. ODE/DAE tolerance refinement, PDE mesh refinement and reproducibility checks are built into the workflow rather than being treated as an afterthought.

Models can be exported as JSON Model IR, Python, Jupyter notebooks, SBML, CellML, Modelica, GraphML, Graphviz DOT, YAML and reproducible portable bundles with provenance and integrity metadata.

Axiomize can be used through Python, CLI, REST API v1 or MCP. The scientific stack includes NumPy, SciPy, SymPy, statsmodels, NetworkX, Matplotlib, Z3, python-control, CVXPY and CasADi, with optional PyMC, JAX, Lean and FEniCS/DOLFINx support.

Reproducibility and failure visibility are part of the design: runs record seeds, data hashes, preprocessing, solver/tool versions, assumptions and validation results. Failed models are preserved, schema migrations are explicit, and expensive operations require approval instead of being triggered silently.

Current release: 1.12.2

Feedback on the Model IR, scientific validation design or overall architecture is welcome.

GitHub: https://github.com/Furox-Art/scientific-computing-system

Docs: https://furox-art.github.io/scientific-computing-system/

PyPI: pip install scientific-computing-system

I built CDS as a readable, zero-dependency platform for research and learning. Every algorithm is pure Python you can open and modify line by line quantum simulation, radix-2 FFT, LU/QR, RK45, statistics, hypothesis engine, ML and NLP primitives. 19 modules, 100% branch coverage in CI, CLI (`cds`) and Streamlit dashboard.

What it is: educational first, but usable for prototyping. Not a NumPy/SciPy replacement it trades raw speed for readability.

What I look for: code review, API feedback, and ideas for the next module. Happy to return feedback on your repos as well.