Take the Brick Off the Pencil

Doug Engelbart — the man who gave us the mouse, the graphical interface, and hypertext in a single 1968 demo — once taped a brick to a pencil to prove a point.

He handed it to people and asked them to write. And they could, technically. The pencil was still there. Every capability it ever had was intact: the graphite still met the paper, the words still formed. But writing became so slow and so effortful that nobody wrote anything worth reading. Try to write with a brick tied to your pencil and you can’t form a sentence, let alone an argument.

That was the point. Engelbart called it de-augmentation. He wasn’t showing that a bad tool makes work impossible. It doesn’t, and that’s exactly what makes bad tools so dangerous. A bad tool makes work possible but prohibitive, and prohibitive is where ambition quietly dies. De-augment the low-level tool and everything you’d build on top of it collapses. Not because the capability is gone, but because the interface taxes every single stroke.

The lesson, sixty years old and still underpriced: the interface isn’t packaging around the capability. The interface is the capability. A good tool for writing is a pencil. A bad tool for writing is a pencil with a brick taped to it. The brick isn’t the villain. A brick is a perfectly good tool for brick-shaped jobs. The failure is the mismatch: a tool is only good or bad relative to the hand that holds it and the work it’s asked to do.

The interface is the capability.

We’ve taped a brick to the agent’s pencil

Now look at what we hand AI agents.

We give an agent a task and point it at the knowledge it needs — which lives in wikis written for human readers, PDFs formatted for human eyes, file trees organized by human habit, dashboards built for human glances, and search engines tuned for human patience. Every one of those tools was designed for a person. None of them was designed for the thing we just asked to use them.

The knowledge is technically there. That’s what makes it easy to shrug off. The agent can search the web. It can RAG across ten thousand documents. The graphite still meets the paper. But watch what actually happens: the agent retrieves fragments without knowing which are current, chunks without knowing what they connect to, claims without knowing who stands behind them. It can’t read everything, so it samples. It can’t verify, so it guesses. It burns through its finite context window hauling the brick instead of writing.

RAG over a pile of files isn't giving an agent knowledge. It's giving an agent a pencil with a brick taped to it.

We already know how this story goes, because we ran it on humans first. We built systems where a person had to touch a hundred screens to do one deal, entering data to generate a run to produce a report to satisfy a system. A tax, not a tool. Then agents arrived, and instead of fixing the tax we transferred it. The report nobody reads has become the context nobody curated. Same brick, new hand on the pencil.

What a pencil for an agent looks like

The instinct, when an agent stumbles, is to reach for a smarter model. That’s like responding to the brick by hiring a stronger writer. The writer was never the problem. The fix isn’t more capability on one end of the interface. It’s removing the tax at the interface itself.

A pencil is a pencil because its entire design assumes the shape of a human hand. So ask the question nobody asked before taping the brick on: what shape is an agent’s hand?

An agent doesn’t skim, doesn’t infer credibility from a URL, doesn’t remember what it read yesterday. What it does brilliantly is traverse structure: follow an explicit link, compare explicit claims, act on explicit provenance. It doesn’t need knowledge that’s searchable. It needs knowledge that’s legible: every fact says what it’s about, where it came from, who asserted it, and how it connects to the next fact, so the agent spends its reasoning on the task instead of on archaeology.

That’s a graph of grounded, trusted knowledge — and it’s what we’re building at WarmHub. Not another place to pile documents and hope retrieval gets lucky, but knowledge in the form agents actually consume: curated, grounded, traceable, the kind someone will put their name on. The right context, to the right agent, at the right time. When an agent asks WarmHub a question, it doesn’t get five hundred maybe-relevant chunks to wade through. It gets the fact, its source, and its neighbors. It gets a pencil.

The interface is the whole game

There are three parts to making an agent useful: the guessing machine, the code that wires it up, and the knowledge you feed it. The first two are racing toward commodity. The model is a guessing machine, and however good the guesses get, they’re only as good as what you hand it to guess from. Your Model Is a Guessing Machine digs into why. The knowledge is the third part, and it’s where the leverage lives. The brick experiment tells you why: capability that arrives through a prohibitive interface might as well not exist. Every month the models get more capable, and every month that capability is throttled by knowledge delivered in a form built for someone else’s hands.

The familiar move is to keep pointing agents at our documents, our wikis, our search boxes, and to keep blaming the model when they flounder.

The better move is simpler. Build a tool for the hand that’s actually holding it.