A workplace you and your agents can both understand.
Observed in my own workflow on August 1, 2026.
When I start a new session, I name the subject. In my current Home, the agent can reload the relevant place, Material and repository Routes from owned files instead of reconstructing everything from the chat.
That place is a Home.
Open Workplace is the model. Endroit is the implementation. This is the Home I actually use.
My Home sits above the conversations and repositories it coordinates. A chat is a Meeting: useful, bounded and ephemeral by default. A Room owns a durable subject. Files hold Material and accepted decisions. Independent repositories remain sovereign Sites. I decide what crosses each boundary.
Endroit builds provider-specific Codex and Claude projections from the same owned workplace sources. Those surfaces are L1 Projection-qualified; this release does not claim a provider-hosted resume path. The underlying Home remains legible without either runtime.
In one launch sequence, Claude produced a research candidate and I retained it in the Endroit Room. I later opened a new Codex Meeting, named the same subject and continued from that retained Material. Codex did not remember Claude. Both entered the same owned place.
The providers supply execution: model, tools, sandbox and session hot state. They can keep useful history or cache, but they are not the only canonical source of my work. The Workplace owns the continuity I expect to recover.
A chat is a meeting
Open Workplace begins with a small distinction: a chat behaves like a meeting.
A meeting has a purpose, participants, and an end. Ideas appear inside it. A few deserve a life after the meeting, while most belong to the exchange that produced them.
A chat makes a weak permanent home for work. The provider controls its interface. Context windows change, summaries compress details, and a new session may retrieve a proposal without knowing whether I accepted it.
I use a Workplace for the durable layer. In Open Workplace, a Home is one concrete, owned workplace and trust boundary. Inside it, a Room holds a subject that needs continuity, such as a product, a research question, or a publication. I can enter that Room from a new conversation and recover its current orientation.
The responsibilities matter more than the names:
- The conversation holds the current exchange.
- Files hold durable material and decisions.
- Repositories and external systems keep their own authority.
- I decide what crosses each boundary.
Endroit implements this model with ordinary files, generated provider surfaces, and a small command-line kernel. Open Workplace remains a proposal that others can examine and challenge. Endroit is one local-first, headless, file-based implementation.
The owned files remain the source. Codex and Claude receive projections adapted to their interfaces. I do not maintain a separate truth inside each provider's instruction format. Endroit rebuilds those surfaces from the Home.
Keeping output without declaring it true
Agent output begins as an ephemeral candidate. It becomes Workplace Material only when I choose a durable transition. I can preserve a useful result without making it current truth.
I use a small lifecycle:
ephemeral → retained → accepted → delivered
└────────────→ archived
retain keeps a result available for later inspection. I use it for studies, design candidates, handoffs, and unfinished arguments.
accept records my decision in the Room that owns the subject. A future agent can distinguish the current position from earlier proposals.
deliver sends an authorized result toward an independent destination. A product repository, website, or publication remains a sovereign Site. The Home reaches it through a declared Route.
The provider may remember the session. The Workplace must remember the work. That distinction lets the execution change without silently changing the owner.
This separation helps with work across several repositories. I do not need to merge them into one codebase or copy their sources into the Home. The Home records why each repository matters. Each repository keeps its code, history, review process, and release lifecycle.
The agent and I tested that boundary during the Endroit reset. Existing checkouts stayed in place. Endroit represented them as existing Routes instead of moving them to fit a new diagram. The agent then created a managed clone and worktree under my direction.
While dogfooding Endroit, I found that a symlink could make a removal target resolve outside the managed checkout. The shared fix now rejects symlinks, indirect real paths and checkout identity changes before deletion. Working against real checkouts produced evidence that an architecture diagram could not provide.
A green build can still be wrong
A recent design task captures the pattern.
While developing the Open Workplace proposal after a major reset of Endroit, I wanted a canonical widget that could explain the model. The main agent checked the current product sources, separated established decisions from experiments and proposed an interactive cross-section of a Home.
I asked for three variants in my interface lab. A delegated implementation task built them as separate experiments. The existing tests passed, the site built and each page returned HTTP 200.
Then I opened the variants. They showed a Home, Rooms, Material, Routes and Sites, but they missed the relationship I cared about. The Workplace should have formed the larger frame, with a Home as one concrete instance inside it. The implementations satisfied their tests while explaining the wrong model.
I rejected the direction and kept the variants as evidence. Seeing the failure made the missing relationship easier to name.
I meet the same situation in code, research and writing. Agents produce candidates faster than I could produce them alone. Tests show whether an implementation satisfies its declared contracts. I decide whether those contracts express the right model.
The loop behind the tools
My recurring loop looks like this:
human intent
→ verified context
→ explicit decision
→ bounded action
→ observed evidence
→ human judgment
→ reusable material
I often begin with an outcome I want and an implementation I do not yet understand. The agent inspects the relevant sources, separates evidence from inference and identifies the remaining unknowns.
The agent and I discuss the direction before I authorize an action. The authorization has a scope: a set of files, a local mutation, a database fixture, a draft or an external effect. The agent returns something I can inspect, such as tests, a rendered page, a Git tree, a browser response or a document.
I then accept the result, ask for another iteration, retain it as a candidate or discard it.
That selective loop is what I mean by compounding. Retained Material, accepted decisions, stabilized methods, verified repository Routes and observed deliveries can prepare a later Meeting. Keeping every output would only create another inbox.
A Git history rewrite provided a strict example. The agent created a local backup, showed me the proposed commit structure, verified that the resulting tree contained the same files and ran targeted tests. It stopped before the force push. I approved that external effect in a second exchange after reading the evidence.
On another task, the agent prepared a deployment recipe through the last reversible step and left the final external action to me. It handled the setup and checks while keeping the consequential decision visible.
The same review prevents unnecessary work. During a staging data task, an agent recommended a broad synchronization. I questioned the scope after the run had started. Two flows would have covered the feature under test. I let the current run reach a safe boundary, narrowed the next one and added the lesson to the operating notes.
In another case, a database assistant appeared to ignore my prompt. The agent reproduced the behavior without running a production query. The database connection worked, but the integration had never started its command-line process. Additional prompting would have repeated the symptom. Inspecting the execution path found the boundary that had failed.
I use the system to inspect, redirect and resume agent work. Accuracy still depends on evidence and judgment.
Conversation remains the interface
I spend most of my time talking to the main agent in natural language.
I bring partial ideas, screenshots, objections, and hunches. I ask it to inspect the current state before recommending a change. I also tell it when a technically valid answer misses my intent.
The explicit verbs are optional precision controls. I use them when I need to recenter a Room, retain a candidate, accept a decision or name a delivery boundary. Ordinary conversation remains enough for ordinary work. A casual acknowledgement does not silently persist or publish anything.
The main agent works like an editor who holds the current question. Delegated agents work like reporters with bounded assignments. One may inspect code while another researches adjacent systems. The coordinator gives each task the context it needs and combines the reports. The delegated agents do not need to talk among themselves.
Delegation has a cost. The coordinator consumes context, and parallel research can generate more material than I can judge. I delegate when the boundaries are clear and the outputs can be compared. I keep small checks, approvals, and decisions in the main conversation.
I also use HACP, an independent optional draft protocol for explicitly invoked moves and controls. It can compose with Endroit, but neither requires the other. Ordinary conversation remains the default.
One interface across different kinds of work
The same pattern has supported a game prototype, research on agent runtimes, UI experiments, public writing, website work, Git repairs, database investigations, and release preparation. The conversation remains familiar while each task demands different evidence.
For code, I want the changed files, tests and root cause. A plausible fix once targeted the reported Git symptom. I rejected it. Further inspection connected the behavior to the shared worktree setup, so the agent fixed the common path instead of one checkout.
For interfaces, I want rendered results. My UI lab lets agents build parallel interpretations without promoting the first design to canon. I have rejected complete visual series after viewing them at their intended size. During another launch pass, the tests and production build passed while a Markdown table appeared as raw text. Opening the page caught it.
For research, I want source classifications, contradictions, and limits. Several agents can scan different bodies of evidence, while the main session distinguishes independent findings from my interpretation.
For external effects, I want a checkpoint. An installer that proposed changing global configuration first produced a dry run and a list of affected paths. A disk cleanup began with measured candidates and explicit exclusions. It removed caches only after I approved the batch, while leaving databases and project data alone.
Files allow each task to contribute to the same body of work without preserving its transcript as memory. A research result can become a Study. A design can remain Material. An accepted conclusion can become a Decision. A Site receives a change through its own delivery process.
The counterargument: a folder may be enough
You can get much of this value from a well-kept folder.
One orientation document, a few subject directories, an AGENTS.md, and a current handoff may cover the needs of one person working with one provider and one repository. A framework can add vocabulary and maintenance without solving a current problem.
Endroit introduces costs:
- I must maintain the Home and its owned sources.
- A failed build can leave generated projections stale.
- Migrations can break old Homes.
- Durable material requires curation.
- Controls and traces add weight to conversations.
- Provider hooks change over time.
A dated audit pushed the live HUD close to its context budget. Adding another Room and two Sites then exceeded the old budget, so I raised it temporarily and opened work to segment the projection. Loading a whole workplace into each Meeting would recreate the overload the workplace was meant to reduce.
Tests also create false confidence when they cover the wrong path. A broad suite can pass while the relevant interface fails. I now ask which check would fail if the claimed behavior broke.
Agents amplify bad premises. Detailed instructions can lock an agent inside a model I misunderstood. I have reduced low-level direction and become stricter about the objective, evidence, and final judgment.
Provider portability remains incomplete. At one dated checkpoint, I had L1 projection qualification for Codex and Claude. I had not proved each provider-hosted resume path across versions and platforms. Plain files reduce dependence on a single model. Adapters and interface behavior still matter.
A structured Home also carries privacy risk. Good organization helps an agent find relevant context. Weak boundaries can expose professional material, credentials, customer information, internal URLs, or raw transcripts. I keep those details outside public examples and limit each task to the sources it needs.
Endroit earns its maintenance cost when it reduces the effort required to preserve these boundaries across sessions, providers, and repositories. A folder remains the better choice while manual conventions still hold.
Hygiene became concrete only after the Home had owners and lifecycles. The system can flag a misplaced instruction, an overloaded Room or an ambiguous destination and explain why. Inspection stays read-only; I decide whether a specific correction should happen.
I delegate more without outsourcing direction
I once felt that I needed to understand the whole path before asking an agent to execute it. That habit reduced some mistakes, but it limited each task to tools and concepts I already knew.
Now I can begin with an intention, inspect the exploration, and learn through the decisions. I can enter an unfamiliar domain before mastering its tools, while still learning the mechanisms that affect the outcome.
I write less code by hand. My syntax recall may weaken when I stop exercising it. I spend more time comparing approaches, spotting category errors, and connecting work across disciplines.
The trade can fail. An agent can produce polished work that I cannot evaluate. Faster output can hide weaker understanding, and creative work can converge on familiar patterns.
I use a practical test: after the session, can I explain the decision in my own words? Can I spot an attractive inconsistency? Can I apply the distinction to another problem?
The Workplace supports that discipline because I can preserve an iteration without accepting it. I can ask another agent to challenge it, then reopen the Room a week later and recover the decision without rereading the meeting.
Try the small version first
You do not need Endroit to test this way of working.
Create a folder that sits above the work instead of inside one agent or repository. Add a short orientation file that answers four questions:
- What work belongs here?
- Which subjects remain active?
- Where do current decisions live?
- Which repositories or external systems own the final truth?
Use one directory per durable subject. Keep candidates separate from accepted decisions. After a useful conversation, preserve one small artifact instead of the transcript. In the next session, ask the agent to read the orientation and the current material for that subject before acting.
Keep external repositories independent. Record how to reach them, and require the agent to show the destination before a destructive or public action.
Try the process across two sessions. If you use two providers, switch providers for the second session. Notice which details survive, which ones you must repeat, and which proposals the new agent mistakes for authority.
Keep the folder if it solves the problem.
Endroit becomes relevant when you need the same discipline across more Rooms, providers, contributors or Sites and the manual conventions begin to drift. Open Workplace supplies the model. Endroit is the alpha implementation I use.
How I assembled this account
One main Codex session delegated three bounded scans over my recent work. The scan located 49 recent tasks and found 37 with useful evidence. Those figures describe one dated pass through my history, not a productivity benchmark.
I compared conversations with the files, repositories, decisions and observed results they produced. A transcript alone would preserve stale assumptions beside accepted decisions.
The agent can change. The workplace remains.
I still decide what is true, what stays private, what sounds like me and what deserves publication.