Nov 20, 2026

Work with your agents, not just through them

By Andrew D. Anderson

Work with your agents, not just through them

Lately, almost every conversation about agents ends in the same place: send them away.

Give an agent a task. Go do something else (maybe assign the next task). Come back to a finished result.

That works. We do it all day. hob runs agents in parallel, in the background, and on a schedule, and we rely on every one of those modes to build hob itself. But the popular story skips a lot of nuance.

A delegated result arriving without the work behind it is not "free". You get a diff, a document, or a table: some high-level condensation of what was done. You do not get how it came to exist, every decision that was made and why. So you have three paths forward when you are presented with the results: check all of it (impractical at scale), interrogate it, or ship it.

Human nature, and all the X commentary, will pull you strongly just to ship it. So you end up in this loop where the more you delegate, the more you ship blind.

Delegation starves intuition

In The future is polished slop, I wrote that polish now is the work. Polish depends on seeing, and it depends on some level of understanding.

When an agent works out of sight, when the creative process is something you do not participate in, you lose your intuitions about the thing that was output. To get it back, you spend time rereading what it wrote. You rerun what it ran. You reconstruct the decisions it made. If you are diligent, you interrogate it to make sure it made the best decisions. Interrogating the result is the closest you can get to having been there, after the fact. This is work, but it is not polish. It is reconstruction, the price of not being there, and you pay it before the polish can begin.

That cost is easy to miss. It's even easier to skip and "yolo". And then... less than excellent results ship to production. And the world is a little worse off for it. But so are you, because you are not learning, you are not cultivating your own intuitions, because you are not participating in any real sense.

Through versus with

Working through an agent is a transaction. You send a request across a boundary and wait for something to come back.

Working with an agent is a shared space. The agent shows what it is doing. You point at what matters. It hands the decision back to you. It asks questions. You ask questions. You leave that experience with more than an agent artifact, you leave with understanding.

Let's take a simple example: On October 2, I asked an agent to walk me through our X analytics. It opened the site in a web pane beside me and moved through it at demo pace, with short notes next to the pointer, while I watched. It collected the numbers from 20 posts and replies into one table. Then it filled in a profile change and stopped before Save.

I did not have to check the table against the site afterward. I had watched it read the site. I did not have to wonder what it would change. The change was on the page, waiting for me. I asked a couple of follow-up questions. It refreshed my memory on some prior decisions we had made. I updated it about the direction I thought we should go.

Same agent. Same model. Different relationship to the task.

The work goes both ways

Most of what we have shipped since September is about that relationship.

The agent can show you things. It operates web pages in view. It points at the exact line, cell, or element it means. It leaves annotations on the file you are reading. It walks you through a task step by step, and it hands a step back when the step is yours.

You can show the agent things. Mark up a web page, an image, or a PDF and send the markup straight to the agent. Point it at a pane, a file, or an issue. Take control at any time.

Agents can work with each other in the same view: one implements, another reviews, and the messages between them stay where you can read them.

None of this works if only one side is designed for. A workspace for people and agents needs two interfaces built with the same care: one a person can read at a glance, and one an agent can operate without guessing. We spend as much time on the second as on the first.

Keep the record

Working together in view is half of it. The other half is what remains after the session ends.

When an agent edits code, a document, a presentation, or a PDF in hob, the change is recorded with its author. You have the option to review it in place and accept or reject it. The conversation stays attached to the work it produced. A week later, you can return to the decision and the reasoning behind it, not only the result.

That record is what makes trust in your workflows durable. It is also what makes delegation safe.

Once you have watched an agent do a task well, and the record shows how it did it, you can save the steps as a skill or an automation and run them on a schedule. You delegate the second time because you saw the first. For careful, skeptical people, that first step is essential. Most tools treat it as optional.

Most people want to work with the agent until the work is right. Only then will they send it through the agent with confidence.

Not just through them

Agents will keep getting better at working alone. That is good, and hob will keep supporting every way of working with them.

But most work that matters still ends with a person's decision. The closer that person is to the work, the less of it they have to reconstruct. Keeping the work in view costs a little speed per task, but it pays you back in understanding, confidence, and quality.

We are not building a better way to send agents away. We are building the place where people and agents do the work together, keep the record of it, and come away understanding it.

Work with your agents, not just through them.