The Conversation Was The Cost

Thirty known small molecules. Three chemistry questions with deterministic ground truth. Two trials each. Eighteen runs in total, on the same machine, against the same model. Nothing else moved between them. Same RDKit descriptors, same dataset, same API, real tokens on a real invoice. Four logical agents in every run: a planner, a structure agent, a property agent and a reporter. One thing changed. The protocol between them, meaning the way one agent hands work to the next. There were three of those. Natural-language messages, which is what almost every multi-agent demo ships. A typed code graph that executes without the model in the loop. And a single 384-dimension embedding that routes the question to the right operation by cosine similarity. The reasoning was held constant across all eighteen runs. The handoff was the only variable on the bench.

TEXT is the protocol most teams ship. Every handoff is a sentence, and a model sits on both sides of it. Averages per query: 18.56 seconds, 5,414 tokens, four model calls, 3,735 bytes on the wire, 91.1 per cent correct. Now read what the work actually was. Take 30 rows of molecular descriptors, filter them, sort them, report the answer. That is a database query wearing a conversation. The 91 per cent is the interesting number. On the second question the pipeline dropped furosemide, a molecule that sat in the input, was scored against a threshold of QED above 0.6, and belonged in a 16-item answer. It scored 0.469 on that one trial. The model re-narrated a descriptor table for the next agent and lost a row on the way through. Nobody shipped a bug. The protocol is lossy on purpose, because prose has no schema, and the loss surfaces as a wrong answer three agents downstream.

The obvious fix is to stop describing the work and start passing it as code. CODE_IR collapses the four model calls to two, one to plan and one to write the answer. The middle of the pipeline is a typed graph that runs with no model in it at all. The numbers move the way you would hope. 2.72 seconds. 428 tokens. 125 bytes on the wire. That is 6.8 times faster, 12.7 times fewer tokens and 29.8 times smaller payloads than the conversation version. Then correctness drops to 79.7 per cent. The plan itself was right: compute the descriptors, then filter on polar surface area under 90 and a Lipinski score of 4 out of 4. The graph did exactly that. The failure sat upstream of the graph. The planner still had to pull the numeric thresholds out of an English question, and it parameterised the filter wrongly. Five valid molecules never reached the answer: ciprofloxacin, loratadine, omeprazole, penicillin and simvastatin. That is the real finding of the experiment. A typed protocol does not remove the failure. It moves it from token drift to argument hallucination, which is quieter and much harder to see in a log.

The third system deleted the planner altogether. The question is encoded once into a 384-dimension vector by a small local embedder, all-MiniLM-L6-v2, 22 million parameters, off the shelf and untrained for this. That vector is compared against the four operations in the library and the best match wins. Top-1 similarity ran 0.76 to 0.89, against roughly 0.55 for the next-best operation, a gap wide enough that no tie-breaking logic was needed. Arguments come from the question's own structured metadata rather than from a model reading prose. Result: 1.67 seconds, 198 tokens, one model call, and it is the last one in the chain, turning the finished answer back into a sentence for a human to read. Correctness: 1.000. Every question, every trial. Eleven times faster than the conversation version and 27 times fewer tokens, and it did not lose a row or drop a molecule once. The only place natural language survived in the system was the place where a human was reading the output.

The reasoning was never the variable. The handoff was.

Translate the meter into a bill at published DeepSeek V3 pricing. Conversation: about $0.0035 per query. Typed graph: about $0.00026, roughly thirteen times cheaper. Vector routing: about $0.00012, roughly 29 times cheaper. Run 100,000 queries a day through the same product and the same chemistry and the same ground truth, and the three bills land at roughly $350 a day, $26 a day and $12 a day. One column looks wrong on the first read. The vector payload is 3,104 bytes against 125 bytes for the typed graph, because it ships two float vectors instead of an instruction. In a production system the operation embeddings sit in a cache and a single intent vector crosses the wire at around 1,500 bytes — against 3,735 bytes of prose that carried far less meaning per byte. The bill was never mostly the model. It was the round trip.

This is a prototype with four operations and one specialist, and it should be read as one. Three things it leaves open. Cross-domain questions, legal plus financial plus medical in a single ask, are not exercised here, and no single operation embedding will capture them. At 400 operations instead of four, top-1 routing precision degrades and you need a hierarchical router. And argument hallucination in the typed graph is demonstrated rather than solved. The fixes named in the write-up are constrained decoding on the arguments, schema validation, and type-checking against the operation signature — a follow-up experiment, not a line of code. The probability that this stays a research footnote is low. A 29-times gap at the bottom of the stack, with the model held constant, does not get quietly absorbed. What the runs actually show is narrower than a thesis about cognition, and more useful. The layer that decides who pays for agents is the layer most teams have never written down: the contract between two agents, and the extraction of parameters that sits just behind it. Keep the model. Change the wire.