Deterministic business rules for AI agents: how neuron-js validates, executes and explains JSON rule scripts

SebaSOFT released neuron-js, an MIT-licensed TypeScript library that stores business rules as pure JSON ExecutionScripts, validates them before execution, and produces an ExecutionExplanation trace of which rules and conditions fired. The library is deterministic and replayable, and ships with a read-only MCP server exposing validate_script, execute_decision and explain_decision tools so agents like Claude Desktop and Cursor can operate rule sets without integration code.

AI agents are getting good at writing business logic. That's exactly the problem. An agent generates a pricing rule that looks perfect: reads well, matches the request, even passes a quick test. But nobody can verify it. Can you replay yesterday's decision? Can you prove to an auditor why customer X got discount Y? Can you be sure the rule that ran is the rule that was reviewed? At SebaSOFT we kept hitting this failure mode while building AI-driven workflow automation, so we built neuron-js https://github.com/SebaSOFT/neuron-js — an MIT-licensed TypeScript library where every rule set is pure JSON, validated before execution, and explained after it. This post walks through why those three properties matter for AI workflows and how the pieces fit together. In neuron-js, a ruleset is an ExecutionScript : a JSON document containing rules, and each rule contains conditions and actions. It serializes, diffs cleanly in pull requests, versions in git, and moves between environments without transpilation: { "id": "volume-discount", "rules": { "id": "discount-rule", "type": "simple rule", "options": {}, "conditions": { "id": "quantity-check", "type": "compare two numbers", "options": {}, "params": { "id": "p1", "name": "op1", "type": "simple number", "value": "${quantity}", "options": {} }, { "id": "p2", "name": "comp", "type": "comparator", "value": " ", "options": {} }, { "id": "p3", "name": "op2", "type": "simple number", "value": "100", "options": {} } } , "actions": { "id": "apply-discount", "type": "add two numbers", "options": {}, "params": { "id": "a1", "name": "op1", "type": "simple number", "value": "${price}", "options": {} }, { "id": "a2", "name": "op2", "type": "simple number", "value": "-10", "options": {} } } } } Two components make this run: Because logic lives in data, an AI agent can author rules — and because the schema is strict, whatever the agent writes gets machine-validated before it can touch anything real. Every execution path validates first: js import { Neuron, Synapse, validateScript } from "@sebasoft/neuron-js"; const validation = validateScript scriptJson ; if validation.ok { // exact errors, nothing executed — ever console.error validation.errors ; } else { const result = new Synapse new Neuron .execute scriptJson, context ; } An invalid script never executes. It returns the exact validation errors instead of a half-evaluated result. This is the property that makes AI-generated rules auditable: the schema is the contract, and the contract is enforced by the runtime, not by convention. Every run can produce an ExecutionExplanation : which rules matched, which conditions evaluated true or false, and in what order. For compliance and debugging this changes the conversation from "trust the engine" to "here is the trace of decision 4821." Combined with determinism — same script, same context, same output, every time — you get replayability: store script + context, replay any decision exactly, prove the outcome matches the trace. The piece that connects all of this to AI agents is the bundled MCP server https://github.com/SebaSOFT/neuron-js/tree/main/examples/mcp-server . Claude Desktop, Cursor, or any MCP client can register three tools — validate script , execute decision , explain decision — and operate rule sets without writing integration code: { "mcpServers": { "neuron-js": { "command": "node", "args": "/absolute/path/to/neuron-js/examples/mcp-server/run.ts" } } } The server is read-only and deterministic. Every tool call validates its inputs first fail-closed again and returns JSON. An agent can validate a rule it just wrote before proposing it, execute it against test contexts, and explain the result — the full authoring loop. Our benchmark harness https://sebasoft.github.io/neuron-js/benchmarks/results.html compares neuron-js against json-rules-engine, json-logic-js, node-rules and hand-coded TypeScript across three scenarios pricing, eligibility, routing and three input sizes. On Node 24, yarn benchmark reproduces every number: The fairness gates and full methodology are in the repo. If a number looks wrong, the harness prints it — file an issue. Because the primary reader of this documentation is often an agent, the site practices what it preaches: an llms.txt router with a full-text variant, Markdown mirrors of every page served at the same URLs rel="alternate" , MCP tools exposed on the site itself, and a type="text/markdown" robots.txt that explicitly welcomes AI crawlers and fetchers. The result is a discovery loop that matches the product: an agent can find neuron-js through a search, read its documentation in clean Markdown, register its MCP server, validate a rule, execute it, and explain the outcome — end-to-end without a human in the middle. The human shows up at the review step, which is exactly where the schema guarantees your leverage. Questions about the benchmark methodology, the MCP integration, or the validation schema? Happy to go deeper in the comments.