Neuraxis and reflexmesh, an Event-Driven Software Controller with Learned Metacontrol
A fast, typed controller for software, files, tools and agents, with the ability to recruit slower language-model reasoning only where the outcome justifies it. The reusable core, reflexmesh, is a public Rust/PyO3 and Python package on PyPI: typed event-driven admission, registered fast actions with verified effects, learned control. Neuraxis is the private app on top: three native file tasks with real findings (verify a software release, reconcile CSV records, audit sources), matched controller executions that expose the controller's evidence, and the scientific pages with shared tabs and a bibliography. The research claim is outcome-grounded allocation of deliberation in a recurrent, resource-versioned asynchronous controller. The corrected evaluation, 19,488 episodes, does not establish learned superiority: the fitted allocation gates select never-defer, and four fixed gates match the learned one. A harder semantic-transfer lane of 1,536 episodes, built so that a fixed controller cannot solve everything, does not establish it either: the always-planner method verified 38 of 128 episodes and the learned controller 18. No AGI or biological claim is made.
Business Context
A controller that acts on files and systems has to be accountable for every effect: registered fast actions, verified outputs, originals untouched, and a slow reasoning path that is a measured recruit rather than the default. That is what makes it usable for release verification, record reconciliation and source audits where a language model alone would be too slow, too costly or impossible to trust with the write. The honest result is part of the product: on the corrected matrix the learned controller M12 reached 1,160 of 1,200 core successes against 1,200 of 1,200 for the exact baseline, both fitted allocation gates chose never to defer, and four fixed-gate ablations matched M12. On the harder semantic-transfer lane no method is perfect: the always-planner method verified 38 of 128 episodes and M12 18, winning 2 paired cases, losing 22 and tying 104, faster because it calls the planner less. An offline routing gate fitted on four families and held out on two delegated zero times on the 32 held-out episodes and verified none, where always-planner verified 10. Learned superiority is not established, and the site, the plan and this card say so.
Strategic Value
The line's pattern is complete here: research dossiers first (source ledgers that distinguish a source read from an experiment reproduced), a defined two-repository plan, the reusable core published from its own repository, and an app that was rebuilt after its owner rejected the simulation-first version and its invented page structure. Private hosted CI was blocked by account billing for a time, and the record kept that failure instead of hiding it; the product and engine CI pass again, and the app is deployed at 0.02.006 on the ML VPS over HTTPS with bounded native operations. No AGI, biological equivalence or learned superiority is claimed; novelty would require the declared ablations and held-out experiments to come out differently than they did.
The Challenge
Agent frameworks route everything through a language model, which is slow, expensive and unaccountable for effects on files and systems, or they hard-code fast paths and lose the ability to think when the situation is new. Fast and slow routing alone is prior art. The open question is whether a controller can learn, from outcomes, when deliberation is worth its cost: a recurrent, resource-versioned asynchronous controller whose fast actions are typed and verified, and whose slow path is recruited only where the expected outcome justifies it. That claim needs declared ablations and held-out experiments before anyone can call it superior, and the first version of the app, simulation-first with an invented page structure, was rejected by its owner.
Our Approach
Two repositories with a package boundary. reflexmesh, public and on PyPI (0.1.1, nine wheels plus a source distribution), owns the Rust/PyO3 admission layer, the typed event model, the learned control and the Python integration. Neuraxis, the private app, owns orchestration, canonical artifacts, the API and the bilingual CAOS workbench, with no internal installable package. The 0.02.000 rebuild made the App do real work on supplied files: verify a software release (map input files, validate source and configuration, check records and relationships, verify declared hashes, build a content manifest, resolve task dependencies, separate accepted and rejected rows, nine verified steps in an execution map with an action inspector), reconcile CSV records, and audit native sources, with independently checked outputs exported and the original files left unchanged. Matched controller executions compare runs and expose the controller's evidence; the five scientific routes carry shared tabs, per-paragraph citations and a complete bibliography. The evaluation is a frozen matrix of 19,488 episodes (14,400 core, 288 structural transfer, 4,800 ablations) plus 36 compound task runs, and a bounded public service consumes the published runtime. Because a fixed controller solves every core task, the core cannot show when a slow reasoner helps, so 0.02.006 adds a separate, hash-audited semantic-transfer lane: eight compositional families, nominal and boundary variants and eight held-out seeds, 1,536 episodes across the twelve methods, each writing real files that an independent check verifies.
Key Performance Indicators
| KPI | Baseline | Result | Impact |
|---|---|---|---|
| Accountable fast actions | Every step through a language model, effects unverified | Registered typed actions with verified effects on supplied files; originals unchanged; outputs independently checked and exported; nine verified steps in the release-verification task | A controller that can be trusted with the write |
| The claim, measured and not established | Fast-and-slow routing declared superior by construction | 19,488 frozen episodes: M12 1,160 of 1,200 core successes against 1,200 of 1,200 for the exact baseline; both fitted gates select never-defer; four fixed-gate ablations match M12. Semantic-transfer lane, 1,536 episodes: always-planner 38 of 128, M12 18 of 128; a held-out routing gate delegated zero times | Learned superiority is not claimed, in the app and in the plan |
| A package boundary that holds | The core buried inside a private app | reflexmesh public on PyPI (0.1.1, nine wheels plus sdist) from its own repository; the app declares no installable package of its own | The reusable part is reusable by anyone |
Proprietary, source code not publicly available
Architecture
neuraxis pipeline
Technology Stack
Application Screenshots
