Essay

The symbol system was right

Forty years ago a whole field bet that intelligence was rules plus facts. It failed on the facts. That part is now cheap, and the rules were right all along. How Cofiled is built, in older words than the ones in fashion.

Updated October 2026 · 8 min read

By Austin Schrader, founder of Cofiled.

Forty years ago a whole field bet that intelligence was symbol manipulation. Write the rules down, feed in the facts, let a deterministic engine draw the conclusions. Expert systems. Logic programming. Newell and Simon called it the physical symbol system hypothesis and said it was sufficient for intelligent action.

It did not work, and everyone knows why it did not work. The rules were fine. The engines were fine. The problem was the facts. Every fact in the rule base had to be typed in by a human being who had read the world and turned it into a symbol. Stevan Harnad named this the symbol grounding problem in 1990: how does a symbol inside a formal system come to mean the thing outside it? Nobody had a mechanical answer. So the systems stayed small, the knowledge-acquisition bottleneck became a cliché, and the field moved on to statistics, where the machine learns from the world directly and nobody has to write a rule.

The statistical turn won so completely that we forgot what it gave up. A rule base is inspectable. Every conclusion traces to a rule and a fact. You can show someone the line. A learned model gives you an answer and a shrug. For a recommendation engine that trade is fine. For a tax return, a benefit determination, a permit, a contract, it is not. Those are domains where the rules are already written down, where being wrong has a cost, and where the person on the other end is entitled to an explanation.

Here is what has changed. The grounding problem has been solved, badly and expensively at first, and now cheaply enough that it no longer matters. A large model can look at a scanned W-2, a bank export, a photograph of a receipt, and say what it is and what the numbers are. It is not perfect. It does not need to be. It needs to be a function with a typed output, and it needs to be graded.

That is the whole insight, and it is smaller than it sounds. You do not put the model in charge. You put it at the door.

The shape

We have been building a tax engine this way for a year, and the architecture is three tiers, enforced by a static check that refuses to boot if a tier is violated.

The first tier is the sensor. A sensor takes unstructured input, a PDF, a CSV, a photo, and returns a value that must validate against a schema. It may call a model. It may not touch anything. A hallucination is a validation failure, not an action. Sensors are the only place a model runs.

The second tier is pure. Pure functions take typed values and return typed values. No model, no I/O, no clock. The tax law itself lives here, as data: every line of every form for every year is a registry entry saying what it reads and what it computes. One evaluator walks the registry. It has never heard of a 1040.

The third tier is the actuator. Actuators send, write, post. They are deterministic code, idempotent by content hash, and no model has ever held one.

A document arrives. A sensor says what it is and what it says. Pure code folds those facts into the graph and evaluates every line the facts reach. An actuator posts the draft. If the graph has an unresolved leaf, the system asks for the document that would resolve it, and the loop runs again. Nothing in the middle is probabilistic. The order documents arrive in cannot change the answer, and we have a simulator that proves it across every permutation.

In older vocabulary: the pure tier is a symbol system. The sensor is a grounding function. The actuator is the effector. The tiers are the sense-decide-act loop every roboticist already knows, with the rule that the estimator never drives the motor directly. Complexity theorists would call the sensor an oracle, a black box the machine may query at designated points, after which you reason about the machine conditional on the oracle's answers. All of these people were describing the same shape. We just happen to be the first generation that can buy the sensor off the shelf.

Grading the oracle

An oracle you cannot grade is a liability. Ours is graded three ways, none of which involve a model judging a model.

The tax authority publishes the answer key. Every filed return we have permission to use is frozen as a fixture: the input documents and the lines the preparer actually filed. The engine recomputes the year and the diff is the score. The set of matching lines may grow and may never shrink; a change that shrinks it does not merge.

Open-source tax calculators written by other people are a second key. A neutral persona spec mints both their input and ours, and the two outputs are diffed line by line across every year both cover. We have found dozens of bugs in the other calculators this way, and a comparable number in ours.

A seeded fuzzer is the third. Random filers within the supported band, run through both engines, with known disagreements classified so a new one stands out.

None of this is machine learning. It is the oldest discipline in engineering: a measurement, a reference, a log of misses, a fix that is data, and a gate that refuses regression. Every production miss arrives holding the fixture that would have caught it. The engine does not get smarter. It gets corrected.

Why tax first

Tax is the ideal first body of rules for three reasons that have nothing to do with its market size. The rules are fixed and published. The forms are fixed and published. The authority publishes the answers. No other domain hands you a complete test suite for free.

But it is a first body of rules, not the last. Every statute, every benefit program, every permit, every lease, every contract is a symbol system that was written assuming a human would do the grounding. Roughly one in five people eligible for the Earned Income Tax Credit never claims it. Billions in benefits go unclaimed every year, not because the rules are unclear but because getting the shoebox into the rule base cost more than the benefit. The rules were never the bottleneck. The door was.

Once the door is cheap and the rules are data, the body of administrative law becomes executable against the world as it actually arrives. Not an assistant that offers legal advice, which is the model-in-charge design and the one everyone is building. A reference implementation of the rule, graded against the authority's own keys, with the model doing nothing but turning paper into typed facts at the threshold. Every output traces to a rule and a document. You can show the auditor the box.

The second-order effect is the interesting one. Today a statute is written for humans to read and machines to ignore. Once an executable encoding exists and is trusted, the encoding becomes the test of what the statute means. Ambiguities show up as nodes the graph cannot resolve. Contradictions show up as failed gates. People start drafting rules that compile. The symbol system stops being a model of the law and becomes its reference implementation.

What this is not

It is not an agent. An agent decides what to do next. Nothing here decides; the registry already decided, at authoring time, and the plan a customer runs is byte-identical to the plan we tested. Error rate equals authoring quality, which we control, not per-run planning luck.

It is not a platform. Letting customers compose their own workflows would silently revoke the determinism guarantee, because an unbounded plan space cannot be graded. We ship finished workflows and customers configure parameters.

It is not a chatbot that knows tax. The model knows nothing about tax and is never asked. It knows what a W-2 looks like.

The claim

The symbolic program was right about everything except the one thing it could not build. That thing is now a commodity. What remains is the part that was always the real work: writing the rules down as data, grading them against reality, and keeping the model on the right side of the door.

We think this is the shape of the next class of software. Not pipelines, which assume the input is already a symbol. Not agents, which cannot be trusted with the output. Symbol systems with grounded inputs: a formal system whose boundary has been pushed outward to meet the world, without giving up the formal system.