Thinking in Libraries: Why Humans (and AI) Solve Hard Problems by Rewriting the Search Space

Opening — Why this matters now

There is a quiet shift happening in AI.

For years, we optimized models—bigger datasets, larger parameters, faster inference. But recently, the focus has drifted elsewhere. Not toward models themselves, but toward how they use knowledge.

Agentic systems, workflow engines, multi-step reasoning pipelines—they all point to the same underlying idea: intelligence is not just about solving problems, but about structuring them.

This paper, Online library learning in human visual puzzle solving fileciteturn0file0, makes an uncomfortable observation.

Humans don’t solve complex problems by brute force or even by optimal logic.

They solve them by quietly rewriting the search space.

Background — Context and prior art

Traditional AI—and much of classical cognitive science—frames problem solving as program induction: given inputs and outputs, infer the sequence of steps (a program) that connects them.

This framing is elegant, but brittle.

Because the search space grows exponentially.

A slightly more complex problem doesn’t feel “slightly harder.” It becomes intractable.

To cope, most systems rely on fixed representations:

• predefined primitives
• static feature spaces
• hand-designed abstractions

Which works—until it doesn’t.

Humans, on the other hand, do something more fluid.

They create intermediate structures—chunks, patterns, shortcuts—and reuse them. Chess players see positions, not pieces. Programmers think in functions, not lines.

In AI terms, this is known as library learning: building reusable subroutines that compress future computation.

The catch?

Most existing models learn these libraries offline—reprocessing past tasks repeatedly.

Humans don’t have that luxury.

They learn online, with incomplete information and uncertain futures.

That difference turns out to matter more than expected.

Analysis — What the paper actually does

The authors design a deceptively simple experiment: a visual puzzle system called the Pattern Builder Task (PBT).

Participants reconstruct patterns using basic geometric primitives—lines, squares, reflections—and can save intermediate results as reusable “helpers.”

These helpers persist across tasks, effectively forming a growing personal library.

From a computational perspective, this maps neatly onto program induction:

• primitives → base functions
• transformations → operators
• helpers → learned abstractions

The system then compares human behavior against four model variants:

The key addition is subtle but powerful:

After solving a task, the solution itself becomes a new primitive.

Formally:

$$ P^{(i+1)} = P^{(i)} \cup {p^{(i)}} $$

Each solved problem reshapes the future search space.

Not by speeding up computation.

But by changing what counts as a “basic” operation.

Findings — Results with visualization

The results are less about accuracy—and more about how effort scales.

1. Humans converge on reusable abstractions

Early in the experiment, participants create many helpers.

Not efficient ones—just complete ones.

Over time, they become selective.

By later stages, helper usage dominates solution steps (up to ~87%).

Participants are no longer solving puzzles.

They are composing abstractions.

2. People independently discover similar “libraries”

An interesting convergence emerges.

Different participants begin saving the same helpers.

This mirrors the model’s heuristic: store complete solutions as reusable units.

In other words, abstraction is not arbitrary.

It is structurally constrained.

3. Difficulty is not about solution length

Here is the paper’s most important result.

Two metrics are compared:

Only one predicts human effort.

This is the pivot.

Humans struggle not because solutions are long.

They struggle because they are hard to find.

And helpers reduce difficulty by compressing the search space—not by shortening the final answer.

4. Learning persists beyond the task

In the free-play phase, participants continue to:

• reuse learned helpers
• invent new abstractions
• create semantically meaningful designs

This suggests something deeper.

Abstraction is not just a tool for solving tasks.

It becomes a mode of thinking.

Implications — Next steps and significance

The implications extend well beyond cognitive science.

1. Agentic AI is fundamentally about library construction

Most “AI agents” today are framed as planners or orchestrators.

But this paper suggests a different lens.

The real capability is not planning.

It is incrementally rewriting the action space.

Agents that:

• store reusable workflows
• compress repeated reasoning
• adapt representations over time

will outperform those that simply search better.

2. Workflow is the new model architecture

This aligns with a broader industry shift.

The competitive edge is moving from:

• model quality → process structure
• prompt engineering → workflow engineering

Library learning is the missing layer between them.

It explains why private data and domain-specific workflows create defensibility.

They reshape the search space in ways outsiders cannot replicate.

3. Efficiency is path-dependent

A subtle but important point.

Participants improved without seeing future tasks.

They built abstractions anticipatorily.

This creates path dependence:

• early choices influence future efficiency
• different trajectories lead to different capabilities

For businesses, this means:

The value of AI systems compounds not just with data—but with structured reuse.

4. Evaluation metrics need to change

Most benchmarks focus on outputs:

• accuracy
• loss
• final solution quality

This paper suggests those miss the point.

What matters is:

• search cost
• reasoning efficiency
• abstraction reuse

In short: how the answer is found, not just the answer itself.

Conclusion — Wrap-up and tagline

There is a tendency to think of intelligence as something static.

A model, a capability, a fixed system.

But this work suggests something quieter.

Intelligence evolves by rewriting its own building blocks.

Not by solving problems faster.

But by making future problems easier to search.

Over time, the system doesn’t just get better.

It gets simpler—because the world becomes more structured.

And that, more than scale or speed, is what makes complex systems tractable.

Cognaptus: Automate the Present, Incubate the Future.