Skip to content

Chapter 1

The Flow of Thought: How Agents String Ideas Together

Inspired by Working Memory and Cognitive Sequences

If you’ve ever tried to juggle too many things in your head at once, you’ll know the limits of human working memory. Picture this: you’re cooking dinner, answering a child’s question, and mentally drafting tomorrow’s presentation slides — all at the same time. Inevitably, something slips. Maybe the onions burn. Maybe you lose your train of thought mid-sentence. Our brains aren’t great at holding everything in one giant ball.

Interactive Graph (beta)

Toggle graph

Instead, what we do is break complex tasks into steps. First chop the vegetables. Then sauté. Then check the slides. Then return to the conversation. It feels natural, almost invisible — but it’s one of the most powerful tricks of cognition. We don’t demand that our minds solve the entire problem in one monolithic leap. We stitch together smaller moves into a coherent flow.

Agents benefit from the same trick. Asking an intelligent system to handle a massive, tangled request in one go is like asking yourself to play an entire symphony perfectly on the first try. The result is often messy, incomplete, or flat-out wrong. But when we break the task into manageable steps, each step builds on the last, and the final performance is not only more accurate but more graceful.

The Brain’s Analogy: Chunks and Sequences

Cognitive psychology tells us that human working memory holds about seven chunks of information at once (some say fewer). When a task exceeds that limit, we naturally offload parts of it into sequences. Think of solving a math problem on paper: you don’t try to multiply big numbers entirely in your head. You line up digits, carry over remainders, and write down partial answers. Step by step, the bigger solution emerges.

Neurologically, this is tied to the prefrontal cortex, which orchestrates sequences of thought. It’s like a conductor ensuring the violins play after the cellos, not all at once. Without this ordering, thought collapses into noise. With it, ideas march forward in rhythm, one measure after another, until a coherent melody emerges.

That’s the essence of this pattern for agents: don’t overload the system with the whole symphony. Give it the sheet music in parts.

Why Flow Matters for Agents

Let’s imagine you ask an agent:

“Read this market report, extract key insights, identify emerging trends, and write a draft email to my team.”

If the agent tries to do all of this in one pass, chances are it will miss something. Maybe the email is fine, but the trends are vague. Maybe the insights are accurate, but the tone is wrong. It’s like throwing everything into one overloaded blender.

Instead, with a cognitive flow:

  1. First, summarize the report.
  2. Then, highlight the three strongest trends.
  3. Next, pair each trend with supporting evidence.
  4. Finally, draft the email using those pieces as ingredients.

Each step is clear. Each builds on the last. And the end result feels deliberate rather than haphazard.

This is not just efficiency; it’s reliability. By decomposing thought, agents avoid the common pitfalls of skipped instructions, context loss, or hallucination.

Everyday Examples

  • Storytelling: A writer drafts an outline before filling in chapters.
  • Cooking: A chef preps ingredients before layering flavors in the pan.
  • Education: A teacher explains a concept step by step, not in one overwhelming lecture.
  • Conversation: We naturally build on turns of dialogue rather than unloading everything in a single monologue.

Each of these mirrors the same brain principle: break it down, string it together, and let the steps flow into something bigger.

Agent Design Lessons

  • Clarity: Each step can be inspected, debugged, or improved independently.
  • Accuracy: Errors are caught earlier, before they cascade into the final output.
  • Flexibility: Intermediate steps can interact with tools or external data, enriching the result.
  • Human-likeness: The stepwise rhythm feels more natural and understandable, echoing how people solve problems.

Pseudocode Sketch

Here’s a simplified sketch that captures the flow:

task: "Create a project update email"
steps:
  - summarize(source_report)
  - extract_top_trends(summary)
  - format_evidence(trends)
  - draft_email(evidence)
result = run(steps)

Notice how the system doesn’t leap straight to the final email. It moves through stages, each small enough to handle, yet together producing something robust.

Conclusion

The flow of thought — breaking a problem into smaller, connected steps — is one of the most powerful design insights from neuroscience. Our brains evolved to handle complexity by chunking it into sequences, and agents thrive when we do the same.

When you see an intelligent system produce a polished, nuanced result, it’s rarely because it got everything right on the first try. More often, it’s because it walked through the problem step by step, each part building on the last. Just as the brain strings together thoughts into coherent action, agents that follow this pattern learn to turn complexity into clarity.