Software Factory Archive

It wasn't a formal decision. Nobody scheduled a meeting about it. It emerged the way all the factory's best innovations emerged—from the accumulated friction of daily practice, rubbed smooth by repetition until a new shape appeared.

The problem was communication. Not between the humans—three people in a room didn't have communication problems. Between the humans and the agents. The scenarios were precise, but the scenarios described outcomes, not instructions. When a human needed to give an agent direction—a new goal, a constraint, a clarification—they used natural language. And natural language was ambiguous. It was always ambiguous. That was its strength for poetry and its weakness for engineering.

But code was too rigid. Writing instructions in code defeated the purpose of the factory. The whole point was that humans described the world and agents translated those descriptions into code. If the descriptions were themselves code, you'd just moved the problem one level up.

What emerged was something in between.

It started with Justin's NLSpec format—the Natural Language Specification files that lived in the Attractor repository. Human-readable specifications that were structured enough for agents to parse unambiguously. But over the months, the format evolved beyond specifications. It became a protocol. A way of speaking to agents that was neither prose nor code but a hybrid: structured enough to eliminate ambiguity, flexible enough to express intent.

Jay noticed it first. He was reviewing his own scenario files from July and comparing them to his scenarios from January. The July scenarios read like English paragraphs. The January scenarios read like something else—still English, still readable, but with a cadence and structure that a programmer would recognize. Sections. Constraints. Preconditions. Expected states. Each sentence doing exactly one job, with no room for misinterpretation.

"We invented a language," Jay said.

"We discovered a language," Justin corrected. "It was already forming in the NLSpec conventions. We just let it mature."

Navan documented the protocol in notebook #10. Not formally—the factory didn't do formal documentation. But he captured the patterns. The way goals were stated. The way constraints were expressed. The way edge cases were specified. The vocabulary that had stabilized: must, should, when, unless, given that. Each word carrying precise semantic weight, the way keywords carry weight in a programming language.

"It's not natural language," Navan said, reading back his notes. "And it's not code. It's the language you speak when you're a human who needs to be understood by a machine without losing the parts of your intent that only a human would think to express."

The protocol had no name. They never named it. Naming it would have implied it was finished, and it wasn't finished. It was still evolving, still being shaped by daily use, still growing new conventions as new situations demanded new kinds of precision.

But it worked. The agents understood it. The humans could write it. And the gap between intention and implementation—the gap that had defined software engineering since its inception—grew narrower every day.

The protocol was the bridge. And three people were walking across it.