Crystallization: When Questions Find Their Own Answers

Merivant — 2026

From building systems where unresolved questions do their own work. A companion to The Instinct Tax, The Core Instinct, and Organize, Not Humanize. Based on what we've seen in practice, grounded in existing research.

The net in the river

Drop a net in a river and walk away. Come back tomorrow. The net didn't chase anything. It didn't swim upstream looking for fish. It held its shape, and the river did the rest. What you find caught in the mesh is a function of two things: the geometry of the net and the contents of the water.

That image has been sitting with me since we started building systems that handle unresolved questions. Because most software treats a question the way a person treats an errand. Something to check on. Something to follow up about. Something that sits on a list until someone remembers to look at it.

But what if the question could do its own work?

The problem with polling

Most systems resolve questions the same way: periodically. A cron job runs every hour. A daily standup asks "any updates on X?" A notification pings you to review something you flagged last week. The question doesn't do anything between those check-ins. It just waits for a human to pick it up, look around, and decide whether anything has changed.

Every one of those check-ins is a cost. Not just compute cost or calendar cost. It's a cognitive cost. You have to reload the context of the question, remember why you asked it, scan for relevant information, and decide whether the answer has arrived yet. Most of the time it hasn't, and you put it back down. That cycle is what we've called the instinct tax: the friction imposed on natural behavior by systems that require you to manually pump information through them.^[1]

Polling is the instinct tax applied to curiosity. You had a question. The system turned it into a recurring chore.

The question should do the work, not the person.

Think about how wasteful this is. You have a living stream of new information entering your system constantly. Notes, messages, readings, observations, data. And separately, you have a list of things you're wondering about. The two never touch each other until a human manually bridges them. That's like having a river and a net and carrying buckets of water to the net by hand.

Standing queries

The alternative is to give the question a shape and put it in the stream.

In database research, this idea has been around for decades. Terry, Goldberg, Nichols, and Oki described it in 1992: a continuous query is a standing request that produces results incrementally as new data arrives, rather than running once against a static dataset.^[2] The query doesn't scan the whole database every time. It sits at the boundary and evaluates each new row as it's written. Event-driven, not poll-driven.

An open loop, in our architecture, works the same way. It's a data structure with a geometric shape. The shape is defined by its terms, boundaries, and proximity constraints. What words matter. How concentrated they need to be. How close they need to appear to each other. That geometry is the mesh of the net.

Every new piece of information that enters the system flows through every active loop at the moment it's written. The loop doesn't scan. It filters. The river moves; the net holds still. When the content of a new entry matches the loop's geometry, it sticks as evidence. The loop accumulates.

This is fundamentally different from search. Search is pull: you go looking for something. A standing query is push: things come to you. The distinction matters because search requires you to know when to look. A standing query requires you only to know what you're looking for. The timing takes care of itself.^[3]

Precipitation

In chemistry, crystallization happens when a dissolved substance exceeds its solubility limit. Molecules that were evenly distributed in solution begin to aggregate at a nucleation point. They don't decide to organize. The geometry of the molecule and the conditions of the solution make aggregation inevitable once the concentration is high enough. You didn't assemble the crystal. You created the conditions, and the structure emerged because the physics demanded it.^[4]

This is what happens when a standing query accumulates enough evidence. The answer precipitates.

You asked a question three weeks ago. You shaped it carefully. Since then, the system has been writing new entries constantly. Most of them flowed past the loop and didn't stick. But a few did. A data point here. A quote from a paper there. A pattern in the activity log. An offhand comment in a meeting note. Each one matched the loop's geometry well enough to attach as evidence.

At some threshold, the accumulated evidence coheres. The answer isn't one of those individual pieces. It's the shape they form together. You didn't find the answer. The answer found you.

Create the right conditions and the structure emerges because the geometry demands it.

This is crystallization applied to knowledge. Three ingredients: a precise question (the solute geometry), a rich medium (the continuous stream of new information), and patience (time for the concentration to build). Remove any one and nothing precipitates. A precise question in a dry medium waits forever. A vague question in a rich medium catches noise. And a precise question in a rich medium without patience gets pulled out and polled manually, which defeats the whole mechanism.

What makes this different from "just waiting for an answer" is that the loop is actively filtering the entire time. It's not passive. It's selectively permeable. Every new entry is tested against the loop's geometry. The loop is working even when you're not thinking about it. Especially when you're not thinking about it.

The shape matters

Everything depends on the quality of the question.

A vague question is a net with holes too large. Everything passes through. You catch debris and driftwood along with whatever you were looking for, and you can't tell which is which. A question like "What's happening with AI?" will match nearly every piece of information in a modern knowledge stream. It accumulates evidence so fast that the signal is buried in noise. It crystallizes into mud.

A closed question is a net with no holes at all. Nothing passes through because nothing can. "Did John reply to my email?" has exactly one answer, and a standing query is overkill for it. That's a lookup, not a loop. Use a search box.

The productive middle ground is a question with precise edges and open interior. "How are teams adapting their code review practices as AI-generated code increases?" has clear boundaries (code review, AI-generated code, team adaptation) but room for the answer to take a shape you didn't predict. The mesh is tight enough to filter out irrelevant information and loose enough to catch evidence you wouldn't have thought to search for.

Pirolli and Card's information foraging theory describes something similar.^[5] Humans navigate information environments the way animals forage for food, following scent trails and adjusting their path based on the density of relevant cues. A well-shaped loop creates a scent gradient in reverse. Instead of you following the scent to the information, the information follows the scent to your question. The stronger the scent (the more precise the loop geometry), the more efficiently evidence accumulates at the boundary.

This means the hardest part of the system is not the filtering mechanism. It's the question-shaping interface. Helping someone articulate a question with the right geometry is the real design challenge. Too tight and nothing catches. Too loose and everything does. The craft is in the mesh.

Where this breaks down

A loop finds what it's shaped to find. That's the strength and the hazard.

Confirmation geometry

Nickerson's comprehensive review of confirmation bias documented what most of us already sense: people seek and interpret information in ways that confirm what they already believe.^[6] A standing query inherits this problem structurally. The shape of the question encodes assumptions. If your loop is shaped by a hypothesis, it will preferentially catch evidence that fits the hypothesis. Not because the mechanism is biased, but because the geometry is. The net catches what the mesh allows.

This means crystallization can produce beautiful, coherent, completely wrong answers. The evidence accumulates. The pattern emerges. It feels inevitable. And it might be an artifact of the question's shape rather than a feature of reality. The crystal formed, but it formed around the wrong nucleus.

Decay and reshaping

Questions age. The question you asked three months ago might not be the question you need answered today. If loops don't decay or get reshaped, you end up with a growing collection of stale filters cluttering the stream. Each one still catches evidence, still accumulates, still might precipitate an answer to a question nobody cares about anymore. Loop proliferation is real, and it has metabolic cost.

Pruning matters. A loop that hasn't accumulated meaningful evidence in a defined window should lose salience. Its mesh should loosen, its priority should drop, and eventually it should dissolve. The system needs to forget the questions that stopped being worth asking.

The cold start

Standing queries only work in a rich medium. If your information stream is thin, nothing accumulates regardless of how well-shaped the question is. A new system, or a system with narrow inputs, doesn't have enough flow for crystallization to occur. You're holding a perfect net in a dry riverbed. In those conditions, polling is honest and standing queries are theater.

Gestalt traps

Human perception naturally organizes incomplete information into coherent patterns. Gestalt psychology demonstrated this a century ago: we see faces in clouds, constellations in random stars, trends in noise.^[7] When a loop accumulates partial evidence, the temptation to see a complete answer before one has actually formed is strong. Premature crystallization produces fragile structures that look solid but shatter under scrutiny. The system needs a minimum evidence threshold, and the threshold needs to be honest.

What this asks of you

Crystallization is not a feature you ship. It's a way of relating to unresolved questions.

It asks you to stop treating open questions as failures of productivity. An unanswered question is not a dropped ball. It's a filter running in the background, doing work you can't see yet. That reframe matters because it changes what you build. Instead of task queues that demand closure, you build accumulation surfaces that reward patience. Instead of polling systems that interrupt, you build event-driven filters that only surface when the evidence is ready, arriving at whatever I/O channel you happen to be looking at. Open loops conserve momentum. This is the mechanism by which they do it.

It also asks you to get better at asking questions. Not more questions. Better-shaped ones. The quality of your loops determines the quality of your answers. A system full of vague loops is a system full of noise. A system with a few well-shaped loops is a system that organizes information around the person who asked, rather than demanding the person organize themselves around the information. The human can always override the loop, reshape it, or kill it. That authority is non-negotiable.

The data stream doesn't care about your deadlines. It flows at its own pace. Your job is to shape the filter and trust the process.

If you're building systems that need to hold questions open instead of closing them early, we've been thinking about this for a while. merivant.com