Software Factory Archive

Justin asked the question during a Tuesday morning standup. "What is a Context?"

It sounded like a trick question. It sounded like the kind of thing a philosophy professor would ask to derail a lecture for forty minutes. But Justin wasn't being philosophical. He was being precise.

Jay answered first. "A Context is a conversation. An ongoing interaction between an agent and a task."

"That's what it represents," Justin said. "What is it, structurally?"

Navan answered. "It's a pointer. A mutable pointer to the head turn of a branch."

Justin pointed at Navan. "That's it. That's the whole thing. A Context is a mutable pointer. Everything else—the turns, the blobs, the DAG—is immutable. The only mutable thing in the entire system is the pointer that says: this is where we are now."

The simplicity took a moment to land. Jay thought about traditional conversation storage systems. They copied entire histories when you wanted to branch. They stored full snapshots of context windows. They treated conversations as monolithic documents that got bigger and bigger until the system groaned under the weight.

"Creating a new Context is O(1)," Jay said slowly, testing the idea against his intuitions. "You just create a new pointer. The pointer points at an existing turn. That turn already has its entire history linked behind it through the DAG."

"So if I have a conversation with a thousand turns," Navan continued, "and I want to create a new branch from turn five hundred, I don't copy the first five hundred turns. I create a new Context that points at turn five hundred. One pointer. One allocation. Done."

"And when the new branch appends a turn," Justin said, "that turn points back to turn five hundred as its parent. The two branches share the first five hundred turns. No duplication."

Jay was quiet for a long time. He was thinking about how many systems he'd worked on that treated context as something heavy. Something expensive to create, expensive to copy, expensive to maintain. Databases that groaned under the weight of conversation history. APIs that paginated through thousands of messages just to reconstruct where an agent left off.

"This changes how we think about agent conversations," he said finally. "If creating a Context is O(1), then contexts are cheap. If contexts are cheap, agents can have thousands of them. If agents can have thousands of them—"

"Then you stop being careful about when to branch," Justin finished. "You branch whenever you want. You explore. You try things. The cost of trying is nearly zero."

Navan wrote it down in his notebook. Not the implementation details—he already knew those. He wrote down the implication: When branching is free, exploration is free.

He underlined it twice and turned the page.