Symbolic, testable tools for neural agents: a small neurosymbolic example

Frank Coyle makes an argument I keep returning to: a neural agent (an LLM with tools and a loop) is powerful but ungrounded. Left to itself it hallucinates, drifts, and loops. The fix is not a bigger model; it is to tether the neural core to symbolic, testable tools: structure it can call, whose behaviour is defined and whose outputs can be checked. That pairing is the old promise of neurosymbolic AI: neural reach, symbolic guard rails. Emil Eifrem's "thin agents on a smart substrate" is the same instinct from the platform side: keep the agent thin, and put the durable capability in the shared layer beneath it.

An ontology is one way to build that symbolic layer. It is not the only one. A typed interface, a programmatic data API, and a deterministic evaluation harness are also symbolic and testable, and for a lot of real systems they are the version you can actually ship.

I want to give a small, concrete example, because the principle is easy to assert and harder to show. On a recent engagement, forecasting collision-parts demand for Inchcape, the platform I built is, in miniature, exactly this: symbolic, testable tools wrapped around a set of neural and statistical models. The models were the team's work. The scaffolding that made them legible, comparable and safe to trust was mine, and it is the part that generalises.

Three symbolic tools

A contract. Every model, however different inside, was wrapped in a function with one defined shape: given data and parameters, return predictions in one agreed format. That is a symbolic interface. A caller (a person today, an agent tomorrow) addresses any model the same way, without knowing or re-wiring its internals. The contract is inspectable and stable, which is what makes everything above it composable.

A data interface. A Features API turned exogenous data into a programmatic surface: list what exists, fetch it, join it to the demand panel on the right key. No implicit, hand-rolled merges buried in a notebook. The set of available signals became something you could enumerate and reason about: legible rather than tacit.

A test. The part that matters most is the one that is genuinely testable: a rolling-origin evaluation harness that trains only on history available at each point in time, forecasts at the real operational lead time, and scores the result. The classification that routes each part is recomputed at every step from past data only. This is the guard rail. It makes a claim about a model checkable, and it structurally forbids the most common way forecasting results lie: training on the future. A neural component can propose whatever it likes; the harness decides whether the proposal survives contact with a test it cannot game.

That is the neurosymbolic shape in the small. The neural and statistical models do the reaching. The symbolic tools (a contract, an enumerable data interface, a deterministic test) do the grounding.

Why it matters when the caller is an agent

The reason this is more than tidy engineering: the same tools that let a distributed team search safely are what let an agent search safely. Once every model speaks one contract and every feature is reachable through one API, an agent can drive the search (propose models, assemble inputs, tune them) and every proposal it makes is still checked by a deterministic harness it did not write and cannot bend. Neural proposal, symbolic verification. Exposing those tools through something like MCP is a short step; the substrate is already the honest part of the system.

I ran an automated version of this myself, without an LLM in the loop, a search that looped hyperparameter studies across features and demand classes to measure what each signal was worth. It only produced trustworthy answers because the symbolic layer underneath it was trustworthy. Swap the search driver for a neural agent and nothing about the guard rails needs to change. That is the point.

The small claim

This is a small example: a forecasting platform, not a general architecture, and no ontology in sight. But it is the pattern I believe most of the durable engineering value now sits in: not the neural core, which is increasingly a commodity, but the symbolic, testable tools that make the neural core reliable enough to depend on. That is the substrate data science and AI actually run on, and it is the thing I build.

The structured, section-by-section version of the engagement is in the case study.