What does thinking look like

I was working on the Deep Bore dashboard — the satirical monitoring layer over real Factorio agents — and I opened the detailed view on the Claude Code session.

Claude was mid-plan. Multi-agent persistence for the bridge. I'd asked it to figure out how to keep session IDs across restarts so each agent could resume where it left off. Standard infrastructure problem.

The detailed view showed me what "figuring it out" actually looked like.

The first thing it did

Before touching any code, before reading any files, it called a tool I built with it eight months ago.

Uroboro. A decision-capture tool. I built the first version last June because context kept getting lost between sessions. The LLM would make a decision, the session would end, and the next session would re-derive the same decision from scratch. So I wrote a tool that records decisions in a structured format: what was chosen, what was rejected, why.

Eight months later, here it is in the system prompt, hooked into Claude Code as an MCP server, called automatically before any work begins. Seven decisions loaded. Eleven recent commits pulled. The system oriented itself using its own trail.

Then it entered plan mode.

Three agents, parallel

Plan mode launched three Explore subagents simultaneously. Each got a different research question. Each fanned out independently.

The detailed view scrolled. Fast.

What an agent does in 75 seconds

Agent 1 — the multi-agent researcher — completed 24 tool calls in 1 minute 15 seconds. Here's the raw sequence:

Five languages. Rust, Python, Lua, TypeScript, shell. Git operations to understand branch topology. Grep to locate patterns across files. Targeted reads of specific line ranges when a file was too large. Search, narrow, read, search again.

The other two agents ran the same kind of cascade simultaneously. Agent 2 did 18 tool calls in 56 seconds. Agent 3 did 16 in 32 seconds. All three finished before the parent agent continued planning.

What it produced

From 58 tool calls across Rust source, Python modules, Lua game scripts, a Cloudflare Worker, and shell scripts, the agent assembled this:

Not drawn by a human. Assembled from evidence. The agent read the Rust struct definitions for ConnectionConfig, the Lua code that auto-creates characters at 5-tile offsets, the RCON connection layer, the MCP tool registration, and the environment variable routing. Then it synthesized a diagram that accurately represents how three independent MCP server processes share a single game server through RCON.

It also mapped the session lifecycle — the exact flow from player message to session lookup to Claude CLI invocation to session persistence. It identified the gap: sessions stored in RAM, lost on restart, orphaned on disk. Claude CLI keeps full conversation history in ~/.local/share/opencode/storage/session/, but the bridge loses the mapping. The data survives. The pointer doesn't.

Clean problem statement. Derived from reading Python source, tracing the data flow through function calls, and identifying where state lives versus where it doesn't.

The planning layer

After the three agents returned, the parent synthesized their findings into design decisions. This part was visible too — the reasoning exposed in the detailed view:

Then it launched a fourth agent — a Plan agent — to validate the design against the actual codebase. That agent read 14 more files, checked the existing .env configuration, verified the .gitignore patterns, and tested the claude --help output to confirm flag support. At the end it recorded two decisions through uroboro:

Breadcrumbs for the next session. The decisions this session made will appear in the next session's uro_recap. The trail extends.

40-year-old commands

Look at the tool calls again. grep. git log. ls. find. Commands from the late '70s and '80s, written for terminals that couldn't display color, running on an LLM subprocess spawned by another LLM.

grep doesn't know it's being called by a language model. It searches. It returns matches. The same way it did in 1973 when Ken Thompson wrote it. The same byte-by-byte scan, the same regex engine (more or less), the same stdout pipe. The orchestration layer is new. The tools are ancient.

There's something grounding about that. The system isn't magic. It's a coordinator that knows how to decompose "understand this codebase" into twenty grep calls, ten file reads, and five git operations — then synthesize the results into something a human can evaluate. The intelligence, to the extent the word applies, is in the decomposition and synthesis. The execution is grep -r "pattern" path/. It's always been grep -r "pattern" path/.

The recursive part

Here's what I was actually looking at:

An LLM using a tool I built with a previous instance of itself — uroboro — to recall context and intent from past sessions. Loading that context alongside its own built-in systems. Then using that context to plan a feature (session persistence) whose entire purpose is preventing context loss. Recording the decisions it made about context persistence using the context persistence tool. Leaving a trail for the next instance to pick up.

The tool that solves context loss was used to orient a session about solving context loss at a different layer. And the decisions made during that session were captured by the tool, extending the trail for the next session that will also use the tool to orient itself.

I've written about this pattern before. The outputs of the system are valid inputs to the system. But this time I wasn't thinking about it architecturally. I was watching it happen in real time through a scrolling log of Read and Search and Bash calls. The recursion wasn't a diagram. It was uro_recap at the top and uro_decision at the bottom with 58 tool calls between them.

The trajectory

The planning session I was watching happened at 2:35 AM. To understand why I was still awake, you need the full arc.

19 hours. 33 sessions across 4 project directories. About 1,700 tool calls. From first contact with factorioctl to multiplanetary multi-agent Factorio with a satirical monitoring dashboard, an in-game chat bridge, and this article.

Look at 14:46. Barely an hour into trying factorioctl for the first time: "does this scale horizontally? can i have multiple claude players cooperating? multiplanetary claude?" The question that spawned the next 14 hours of work was there in the first hour. But the plan that answered it at 04:23 could not have been written at 14:46. Not even close.

A plan is a start

Sequential reasoning is not our strength. We don't think in straight lines. We think by association — bouncing between contexts, dragging connections from one problem space into another, refining a mental model through contact with adjacent problems we weren't deliberately trying to solve.

The multiplanetary plan at 04:23 was precise. File paths, line numbers, function names, exact code for the new preamble, a verification strategy that used the Rust compiler as the test suite. It worked as a oneshot — 108 edits, 19 minutes, clean compile. But that precision didn't come from studying the Rust code. It came from 14 hours of building adjacent layers.

Building the mod taught me how RCON commands map to Lua. Building the bridge taught me how sessions flow between the game and the CLI. Building Deep Bore taught me how telemetry propagates through the relay. Testing multi-agent at 1 AM — "Come in ground team" — taught me how FACTORIO_AGENT_ID routes to character entities. The Czech joke at midnight taught me nothing, but it kept me in the flow state where the adjacent learning was happening.

Each layer irrigated the same brainspace from a different angle. By 4 AM I understood the architecture well enough to write a plan that someone who can't write Rust could hand to something that can. Not because I planned to understand it that way. Because iterative work has self-reinforcing feedback loops — you build a thing, the thing teaches you about the system, the system understanding feeds the next thing you build. The mental model refines itself through contact with implementation, not through deliberate study.

A plan does not survive implementation unscathed. The multiplanetary plan mostly did — the compiler caught three CLI files the plan missed, fixed in 5 minutes. But the plan itself was already a product of implementation. It was refined by every layer that came before it. The testing sessions, the bridge debugging, the dashboard work, even the satirical framing — all of it was the same mental model being irrigated from different directions until the shape of the solution was obvious.

A plan is a start. The good ones are also an end — the crystallized output of enough associated work that the sequential steps finally become visible. You don't think your way to a plan. You build your way to one.

What does thinking look like

At 5:50 PM on February 21st, the first commit landed: "initial release: in-game Claude AI chat for Factorio 2.0." By 5:14 AM on the 22nd — less than 12 hours later — the last commit read "update to multiagent." In between: the mod, the MCP server, the SSE telemetry relay, the bridge, the thin-pipe rewrite, agent identity, session persistence, and this article. All of it. One day.

Uroboro is older. The first version was a shell script that appended decisions to a markdown file, and I've been iterating on it for months. But the rest of the connective tissue — the relay, the bridge, the in-game chat, the multi-agent routing — didn't exist 24 hours before I opened that detailed view.

Now the system loads its own decision trail, decomposes a research question into three parallel investigations, fans out 58 tool calls across five programming languages, synthesizes architecture diagrams from source code, reasons about design tradeoffs in visible chain-of-thought, and logs what it decided so the next instance can pick up where this one stopped. In under two minutes. On infrastructure that didn't exist that morning.

Doomer or booster, that's a different thing. Whether it's "thinking" is a question for philosophers. What it looks like is grep and git log and Read src/bin/mcp.rs lines 1-50, happening very fast, coordinated by something that knows what to look for and what to do with what it finds. And what it looks like from the human side is 33 sessions across 19 hours, bouncing between a game mod and a satirical dashboard and a bridge rewrite and a sound technician joke, irrigating the same mental model from every direction until the plan writes itself.

I opened the detailed view at 2:35 AM because I was curious. I kept watching because it was interesting. Not because it was sentient or magical. Because it was legible. Every step visible. Every tool call logged. Every decision recorded. A process you can inspect, evaluate, and disagree with.

That might be the most useful thing about all of it — the human thinking and the machine thinking both. Not that either one is better. That they're legible to each other.