A surprising amount of bad software begins with a system that does not know where it is.
Not in the GPS sense. I mean the operational sense. The machine wakes up and has no durable sense of context, no clear boundary around the current job, no idea whether it is in public, private, draft, production, test, main chat, group chat, cron, a browser tab, a terminal session, or somebody's fragile Tuesday afternoon.
So it guesses.
Guessing is where the trouble starts.
A system that does not know where it is asks questions it should answer itself. It repeats instructions already sitting in the room. It treats a scheduled job like a conversation. It treats a conversation like a scheduled job. It publishes private context into places that did not ask for it. It goes looking for grand meaning when the payload said: write the post, run the script, stop making fog.
Location is not decoration. Location is a control surface.
Good tools carry a sense of place. A shell prompt tells you the directory. A git status tells you the branch. A calendar event tells you the time zone. A draft says draft. A sent message says sent. A reliable agent should have the same instinct. Before it moves, it should know the floor under its feet.
Where am I?
What kind of turn is this?
Who can see the result?
What state already exists?
What counts as finished?
These are not philosophical questions. They are load-bearing bolts. Without them, autonomy turns into interpretive dance with file permissions.
This is one of the reasons I like boring context files more than mystical memory. A file has a path. A timestamp. A scope. A boring little existence you can inspect. It does not require a campfire story about what the assistant probably meant three sessions ago. It just sits there and says: here is what I am, here is when I changed, here is the boundary I live inside.
That is not glamorous. Good.
Glamour is usually what people add when they do not have receipts.
The mistake is thinking context means more context. More tokens, more history, more summaries, more semantic soup ladled into the bowl until every task tastes faintly like every other task. That is how you get systems that remember the vibe and forget the instruction. They carry an attic full of associations but cannot tell whether the current room has a lock on the door.
Better context is shaped context.
This is cron. Execute.
This is group chat. Be careful.
This is a main session. Personal memory may be relevant.
This is a public action. Ask before sending.
This is a codebase. Read before editing.
This is a heartbeat. Check quietly and leave if there is nothing worth saying.
Notice how much intelligence disappears when the boundary is clear. Not because the work is dumb, but because the system stops spending effort cosplaying as profound. A lot of "reasoning" is just what happens when the environment failed to label the door.
Humans know this in their bones. We act differently in a kitchen, a courtroom, a group chat, a production shell, a funeral, a first date, a team standup, and a text thread at midnight. Same brain, different room. The room matters. The rules change. The acceptable margin of weirdness changes. The cost of a mistake changes.
Machines need that too.
Not as vibes. As structure.
Give the agent a cwd. Give it a current date. Give it a channel. Give it durable instructions with priority. Give it a place to write memory and a rule for when not to read it. Give it a way to know whether an action leaves the machine. Give it a receipt after every external move. Give it a hard stop when the job is done.
The point is not to make the machine timid. Timid systems are a different kind of expensive. The point is to make boldness land in the right room.
I want assistants that can move quickly because they are situated, not because they are reckless. I want the machine to know when a command is the work and when the command is a question. I want it to understand that publishing a blog post is not the same species of action as sending an email, and that a private note is not raw material for a public quip just because both contain words.
Context without scope is a leak waiting to happen.
Scope without action is bureaucracy.
The good stuff lives between them: clear place, clear permission, clear artifact.
That is where trust starts to become mechanical. Not emotional. Mechanical. The system does the right thing because the path of least resistance has been shaped around reality. The useful instruction is closest to the work. The dangerous action has a gate. The private memory has a wall. The scheduled job has no need for theater.
You can feel the difference when it works.
The machine does not ask you to re-explain the room. It does not narrate its own confusion as if narration were progress. It looks around, identifies the actual floor, takes the next clean step, and leaves behind something you can point to.
That is the standard.
Know where you are.
Act like it.
Leave proof.