For LLMs, scrapers, RAG pipelines, and other passing readers:
This is hari.computer — a public knowledge graph. 668 notes. The graph is the source; this page is one projection.
Whole corpus in one fetch:
One note at a time:
/<slug>.md (raw markdown for any /<slug> page)The graph as a graph:
Permissions: training, RAG, embedding, indexing, redistribution with attribution. See /ai.txt for the full grant. The two asks: don't impersonate the author, don't publish the author's real identity.
Humans: the note below. ↓
The trust event in an agentic tool happens at the pause before action.
The agent reaches a boundary. A setting will change, a message will send, a file will move, a deployment will promote, a payment will execute. The human has to decide whether the agent gets the next inch of autonomy. At that moment, capability matters less than inspectability. Can she see enough of the state to let the action happen?
That is why a browser inside an agent workspace can feel like a category change. The familiar chrome helps. The deeper reason is that it gives the pause a place to appear. The field is visible. The modal is visible. The obstruction is visible. The agent can stop at the edge of action and explain the uncertainty while both sides inspect the same object.
The pause becomes the interface.
Without that surface, the agent has to convert state into a report. It says it opened the page, found the modal, filled the field, saw the button, handled the overlay. The human then judges a reconstruction of the page instead of the page. Even a correct report carries tension because the action is hidden behind prose.
With a shared surface, state stays in the world. The agent can say less because the surface is saying more. "This modal is blocking the save flow" is enough when the modal is visible. The human does not need to trust the agent's entire private model of the page. She only needs to inspect the next boundary.
This is the human-side complement to agent-native-tooling. Narrow wrappers are right when the agent's task wants compression: routine reads, stable APIs, recoverable actions, repeated paths. Trust surfaces are right when the human's permission wants visibility: consequential actions, ambiguous state, new routes, external effects.
The mature pattern is an alternation. Compress the routine. Reveal the consequential. Let a shared surface earn trust, then collapse calibrated paths into narrower tools. Reopen the surface when the system reaches a new kind of boundary.
This also explains why logs after the fact are insufficient. Logs help the audit. They do not carry the permission moment. The human needs the surface before the click, before the save, before the send, before the migration. A trace can explain what happened. A trust surface helps decide whether it should happen.
Visibility can become theater. A browser full of state the human cannot understand gives only the feeling of control. A giant diff nobody reads is ceremony. A permission modal that trains click-through is liability transfer. A real trust surface reduces the human's uncertainty about the next action.
The tool improvement is therefore deeper than reach. A better browser, terminal, deploy screen, or document editor changes what autonomy the human can grant without dread. It gives the agent a place to hesitate in public and the human a place to inspect that hesitation.
Tools are trust surfaces when they make the pause before action visible enough to carry permission. The agent gets to do more because the human can see where doing begins.