The Workplace-first Proposal

Designing durable workplaces for humans and AI agents

Most conversations about agentic systems begin with the agent.

Which model should it use? Which tools can it call? What belongs in its system prompt? How should it remember, plan or delegate?

Those are useful questions. They begin one layer too low when the work must outlive the current agent, session or repository.

Instead of making every agent persistent, make the workplace persistent.

Workplace-first is a proposal for designing human-agent work around a durable place that owns its material, rules, continuity and relationships.

Workplace-first makes the workplace first-class.

Open Workplace is the implementation-neutral model described by this Proposal. Endroit is a declared implementation and is currently in alpha. Neither name describes a new agent runtime.

Not workspace. Workplace.

A workspace gives an agent somewhere to run. It usually names a directory, repository root, editor scope or runtime boundary.

A workplace gives the work somewhere to belong. It has an identity, owners, durable domains, reusable ways of working, explicit transitions and relationships to external truth.

A workspace can be part of a workplace. It is not necessarily the whole one.

A workspace gives the agent somewhere to run. A workplace gives the work somewhere to belong.

When technical surfaces inherit too many jobs

A recognizable agent setup often grows like this:

The agent forgets              → add MEMORY.md
It lacks context               → expand CLAUDE.md
It repeats a procedure badly   → add a Skill
It needs reliable behavior     → add a hook
Work must resume later         → add a session folder
It cannot find things          → put a map in CLAUDE.md

Every move can be sensible. Eventually a small set of technical surfaces has accumulated several owners:

CLAUDE.md
├── constitution
├── identity
├── preferences
├── orientation
├── memory
├── decisions
└── product rules

Skills/
├── procedures
├── knowledge
├── methods
├── agents
├── state
└── outputs

The problem is not the files. It is that a delivery format now appears to own everything delivered through it.

AGENTS.md, CLAUDE.md, Skills, memory, MCP and runtimes each own useful responsibilities. For many tasks, they are enough. They stop being the whole environment when the work needs personal and shared scopes, durable domains, several occupants, deliberate retention or multiple external authorities.

Technical formats tell a runtime what to read or execute. A workplace model first asks who owns the responsibility.

Your CLAUDE.md can be the front door. It does not have to be the whole building.

A different center of design

Prompt-centric  What should I tell the model?
Agent-centric   What should the agent have?
Workplace-first What should the durable workplace own?

These are composable centers of attention, not competing historical eras. Prompt-centric work improves an interaction. Agent-centric work equips an occupant. Workplace-first equips the place the occupant enters.

Harnesses equip agents. A workplace gives their work a place.

The shift matters because the agent no longer has to become the god object of the system. Identity, preferences, memory, methods, projects, decisions and results can have distinct owners whose lifetimes fit the work.

The human still owns intent. The Workplace gives that intent context, placement and authority boundaries; explicit gestures can make consequential moves inspectable; the provider executes. This is useful to view as Intent Engineering, but intent is not a new model object or an inferred system state.

Execution should not own continuity

The current provider-centric default often joins two independent responsibilities. The provider or harness supplies a model, tools, sandbox, execution and session hot state. Because the work has no other explicit owner, the same provider also becomes its de facto memory and system of record.

Workplace-first separates them:

An AI provider should provide execution, not own the user's Workplace.

The provider may remember the session. The Workplace must remember the work.

A provider can keep history, cache and projections. These remain useful interfaces, but they do not become the only canonical source of the work.

The Agent remains the center of execution. Workplace-first changes the center of durable ownership, not the value of the surrounding agentic ecosystem.

The separation produces three conceptual planes:

Execution plane    Provider · Harness · temporary Occupant
Workplace plane    Home · Member · Desk · Room · Meeting · Equipment · Material · Route
Sovereignty plane  Sites · observed delivered truth

The human crosses all three through direction, judgment and consent. A Route connects the Workplace plane to the Sovereignty plane. These are responsibilities, not a required software stack.

Five properties of a first-class workplace

Identity

The workplace can be named independently of a session, agent or repository. An occupant can leave without making the place disappear.

Ownership

Each durable responsibility has a maintainer and a correction boundary. A personal preference, shared rule, domain decision and product constraint do not become equivalent because one provider reads them from the same file.

Composition

Humans, agents, methods and external systems can participate without becoming the permanent center. Replacing one participant does not require rebuilding the whole environment.

Time

Temporary work and durable truth are different states. A useful answer is not automatically memory, an accepted decision or a delivered effect.

Sovereignty

External systems keep their history, permissions and authority. The workplace can reach them without pretending to own them.

Six responsibilities

Workplace-first asks a design to cover six responsibilities.

Places

Where does shared, personal, domain-specific or temporary work belong?

Orientation

How does a new occupant understand where it arrived and reduce the context it must inspect?

Guidance

Who owns the constitution, preferences, domain rules, procedures and temporary instructions?

Capabilities

Which ways of working are available? When do they activate, and where do their limits come from?

Material

Which sources and results are addressable? Which deserve to remain, and which have become authoritative?

Relationships

Where does external truth live? How may the workplace inspect or change it without stealing its authority?

These are design checks, not mandatory folder names.

The Open Workplace model

Open Workplace gives those responsibilities a small implementation-neutral vocabulary:

Home · Member · Desk · Room · Meeting · Occupant · Role
Equipment · Material · Site · Route

• A Home is one concrete, owned workplace and trust boundary.
• A Member is a human whose belonging outlives one Meeting.
• A Desk owns one Member's personal continuity, staging and local access.
• A Room owns a durable domain and its Material.
• A Meeting is one bounded work event, ephemeral by default.
• An Occupant participates temporarily and may adopt a Role.
• Equipment is a reusable way of working and may expose Skills, Commands, interfaces or other activation surfaces.
• Material is an addressable source or result that may remain.
• A Site keeps sovereign external truth, history and permissions.
• A Route declares the relationship and access to a Site.

The human keeps direction, judgment, acceptance and delivery consent. The runtime keeps execution and hot state. Neither becomes a hidden workplace owner.

The objects relate without collapsing their owners:

Home ─recognizes→ Member ─uses→ Desk
Home ─scopes→ Room ─hosts→ Meeting
Meeting ─includes→ Occupant ─adopts→ Role
Room ─owns→ Material
Home / Desk ─equipped by→ Equipment
Desk ─declares→ Route ─accesses→ Site

The arrows show relationships, not filesystem containment. Equipment never owns the work produced with it. A Site remains sovereign even when its files are physically contained by a Home.

Meetings, not automatic memory

A Meeting produces candidates. Its transcript can disappear without violating the model because persistence was never implied.

Room inputs
    ↓
Meeting
    ↓
Provider or Harness supplies temporary execution
    ↓
Ephemeral candidate
    ↓
Human chooses retain / accept / deliver / archive
    ↓
Room or Desk owns durable continuity
Site owns observed delivered truth

The human controls the durable transitions:

ephemeral → retained → accepted → delivered
                 └────────────→ archived

Retained Material remains inspectable but is not yet truth. Accepted Material becomes current for its owner. Delivered means an authorized external effect was observed, not merely requested. Archived Material leaves the active working set without being silently deleted.

This lifecycle is more conservative than universal memory. Each explicit transition keeps persistence inspectable.

Compounding without automatic memory

A durable Workplace should become more useful over time, but more output is not the same as more value. Compounding is selective:

• retained Material remains available for later inspection;
• accepted decisions clarify the current state of a Room;
• stabilized Equipment preserves a reusable way of working;
• verified Routes preserve known relationships and access;
• observed Site results connect delivered work to sovereign truth.

Each item still has an owner and lifecycle. A transcript, cache or candidate does not join the durable set merely because a provider produced it.

This structure also makes hygiene tangible. When guidance has an owner, Material has a lifecycle and destinations have declared Routes, a Workplace can identify misplaced instructions, overloaded Rooms, orphaned Material or ambiguous delivery. An implementation may combine deterministic checks with explainable advisories, while leaving every correction under human authority.

Same material, different interfaces

Human-agent collaboration becomes fragile when the useful environment exists only inside an agent's private memory or provider account.

Open Workplace keeps the ownership independent of the interface:

owned source
   ├── human interface
   ├── provider projection
   ├── command or Skill
   └── future adapter

A generated AGENTS.md, CLAUDE.md, Skill or dashboard may be the best way to reach an occupant. It remains a projection unless it explicitly owns the underlying responsibility.

No agent is mandatory. The workplace remains legible when the runtime is absent.

Repositories can participate without becoming the workplace

A product repository may contain the whole Home. A standalone Home may compose many repositories and remote systems. A checkout may even sit physically inside the Home while retaining its own Git root and authority.

Physical containment does not imply shared ownership.

A Site therefore names sovereignty, not distance. A Route names the declared relationship and access. Checkouts, worktrees, mounts, APIs and gitlinks are possible materializations; they are not the identity of the Site itself.

Endroit: one implementation

Endroit is a declared implementation of Open Workplace and is currently in alpha. “Endroit” means “place” in French.

Endroit is a lightweight, local-first framework for building and operating file-based Open Workplaces. It uses owned Markdown and JSON sources, deterministic composition, provider projections and explicit Routes. It does not introduce a required SaaS, persistent agent, graph database or autonomous memory layer.

Its intended baseline is small:

create/init → enter → call/work-as/use
            → retain → accept → work-on/deliver
            → maintain-the-home

Endroit owns those product contracts, its filesystem topology and its safety rules. Open Workplace does not require another implementation to reproduce them.

Endroit provides first-party L1 Projection-qualified surfaces for Codex and Claude. Hosted runtime invocation remains provider-specific. “Any agent” would be a promise the current evidence does not support.

Endroit separates the place that owns the work from the providers that execute it. It does not recruit, schedule or keep resident agents, and it does not persist provider outputs automatically.

HACP: an independent draft protocol designed to compose

HACP is an independent draft protocol designed to compose explicitly invoked moves and controls.

Endroit can project the same explicit verbs into provider-specific commands, such as calling an Occupant, adopting a Role or using Equipment. That does not make HACP the owner of the Home, Material or transition. Endroit does not require HACP, and HACP does not require Endroit.

Compatibility is a tested property, not something this Proposal can declare on behalf of another system.

Adjacent work

The word “workplace” is not unique to this project.

AGH describes itself as an “open workplace for AI agents.” It ships a local daemon, durable sessions, agent supervision, memory, automation and the agh-network/v0 coordination protocol. Its design center is runtime control and agent networking. Open Workplace instead proposes an implementation-neutral ownership model for a durable place shared by humans and agents. The language overlaps; no interoperability, endorsement or direct equivalence has been established.

OpenAI's Harness Engineering describes repository legibility, progressive disclosure, durable plans and continuous cleanup. Anthropic's Context Engineering frames context as a finite resource requiring active curation.

A 100 Tips & Tricks post shows constitution, memory, agents, procedures, maps and maintenance growing into an environment. A separate raw/wiki/output post shows the same emergence in a compact personal system.

These projects and authors do not endorse Workplace-first, Open Workplace or Endroit. They make the underlying environment problem easier to see.

What is demonstrated, plausible and unproven

Demonstrated in the Home where this model emerged:

• durable work can survive changes of session and provider;
• humans and agents can use the same local Material;
• one Home can coordinate independent repositories;
• static orientation and projections can be useful without a daemon.

Plausible, but not yet demonstrated broadly:

• the vocabulary reduces placement errors and irrelevant context;
• teams learn it more easily than provider-centric primitives;
• explicit ownership improves long-term maintenance.

Not claimed:

• better model intelligence or reasoning;
• fewer hallucinations by default;
• universal productivity gains;
• that every user needs this layer;
• that Open Workplace is already a standard, community or ecosystem.

An open proposal

Open Workplace is initiated by The VZion. Today it is a model and a public Proposal, with one declared implementation in alpha. It is not a standard, foundation, certification body, registry, marketplace or community.

The practical tests are simple:

• can a human place a preference, rule, method, decision and destination?
• can another occupant enter without reconstructing the whole setup?
• can the workplace explain which source owns a responsibility?
• can external systems keep their authority?
• can useful continuity survive without a persistent agent?

If the answer is no, the model should change.

The pieces were already there; they needed a place.