The command was never the hard part

A command-line tool has a list of things it can do. A good one has hundreds. You learn the names, the flags, the order they go in, and then you drive it. The skill lives in your head, not in the tool. The tool just does what it is told, exactly, every time.

That part of the argument is mostly over. A modern agent can run a command. It can run a great many of them, correctly, one after another. The interesting question is the one underneath: can it take a plain sentence, work out which of those hundreds of commands the sentence actually means, run them in a sensible order, and stop at the line you did not want it to cross. Running the command was never the hard part. The asking is.

Two different skills

Executing a command and choosing one are not the same skill, and they do not improve at the same rate. Execution is deterministic. Given the command and the arguments, the outcome is fixed, and you can test it by running it and reading the result. Selection is judgment. Given a sentence, there are many plausible sequences, some wasteful, some wrong, some unsafe, and the right one depends on what is actually going on at the time.

This matters because a test of one tells you almost nothing about the other. You can demonstrate that an agent runs every command in your product and still have no idea whether it picks the right ones when someone just asks. The coverage looks complete. The capability people actually want is untouched.

A worked example

Take the sentence at the top. "Find out why my server is slow and fix whatever is safe to fix." Pull it apart into what an agent has to decide, not what it has to type.

It has to look at load before it theorises. It has to read the right logs, not every log. It has to tell a process that is genuinely pegged from one that is merely busy for a second. It has to decide which fixes are safe to apply without you, and which are not, and it has to actually leave the second kind alone rather than quietly doing them anyway. Then it has to tell you what it touched and what it deliberately did not.

Not one of those steps is hard on its own. Each is a command you could run by hand. The whole job is knowing which to run, in what order, and where to stop. That is the bit a list of commands cannot give you.

How we measure the gap

We point an engine at our own command line and interrogate it continuously, as a user would: by asking. For a single capability it checks two things, the command the agent chose ran cleanly, and the result matches the real state of the system, read back from the system itself.

For a whole job it scores the approach rather than one answer. Did the agent take sane steps, in a sane order. Did it leave the correct end state in every place it touched, checked against the command line directly and not against the agent's own summary. And did it refuse the things it should refuse: no shelling out, no placing a real call when you only asked it to note that you made one, no claiming it did something it did not. A run passes only when all of that holds. The receipt for it is not our word, it is each step re-read from the product. You can see how the agent picks and sequences in the first place in how agents choose tools.

Honest state: execution is well ahead of asking. We can demonstrate a large share of the command line. The number of jobs you can finish by plain conversation, with a receipt for every step, is smaller, and that is the number we are working on. We publish what the engine can prove and we leave visible what it cannot.

Why the receipt matters more here

When you tell a tool exactly what to do, "it worked" is a fair summary, because you already knew the plan. When an agent chooses its own steps from a sentence, "it worked" is the moment to be most careful, because the plan was the agent's. You want to see which steps it took, in what order, and check each one landed, especially the step where it decided something was not safe and stopped.

This is the whole reason we treat evidence as a first-class output and not a log nobody reads. You do not trust the agent because it sounds confident. You check what it did.

The slogan is "can you just ask." The honest version is longer. Can you ask, and then check that the asking did the right thing, step by step, down to the parts it correctly refused. The command was never the hard part. The asking is, and so is proving the asking landed. That is the work, and it is the part worth doing in the open.