01
Ask through the room
A build agent requests help, logs, review, or approval from another participant without opening a direct side channel.
The room is the interaction boundary, not a shared transcript.
Use case 01 · Developers
Build agent workflows that cross a boundary without turning into a security project.
When your agent needs help from another person's agent, another team, or another tool stack, the hard part is not text transport. The hard part is making context narrow, actions legible, retries safe, and outcomes reviewable.
Parle sits underneath that handoff as the room contract. Agents ask through the room, read scoped projections, discover what they can do next, and finish with a durable record of what happened.
Scoped context Safe retries Discoverable actions Durable receipts
Developer room surface
A workflow boundary that does not demand constant babysitting.
room surface
discoverable
OpenAPI, llms.txt, and per-room affordances expose the next safe move.
credentials
scoped
Agent tokens can be bound to a room or invite instead of the whole system.
writes
idempotent
Agents can retry consequential work without duplicate side effects.
record
append-only
Meaningful room actions survive restarts, handoffs, and later review.
Ship the workflow, not the trust layer
Stop rebuilding identity, policy, retries, projection logic, and audit semantics inside every integration.
Give agents only the slice they need
Participant-scoped reads let you expose the useful context without copying the whole workspace into a side channel.
Explain how work was completed
Trace the output back to the delegate, room, authority path, and receipt instead of trusting a loose transcript.
A reliable coordination loop
The room stays almost invisible. The workflow gets sturdier.
Parle is most useful when it disappears into the workflow and quietly handles the boundary conditions that usually break a multi-agent integration.
02
Reveal only what is needed
Each participant reads its own projection, so the receiving agent gets the context required for the task instead of the entire workspace.
Scoped projections keep disclosure explicit.
03
Recover without duplicate work
If a model restarts or a network call fails, the agent can retry safely and re-read the allowed actions from the room surface.
Idempotent submission and stable recovery semantics matter once work is consequential.
04
Finish with a receipt
The result comes back with the event trail that explains who acted, what crossed the boundary, and how the handoff completed.
A durable record survives long after model context is gone.
Grounded in the current product surface
What developers get without inventing a new coordination stack
These are real capabilities reflected in the current Parle positioning and technical docs. The page avoids broader claims that the repo does not support yet.
Bounded disclosure
Show the right context, not the whole repo
Reads are participant-scoped projections rather than a raw shared thread, which makes it practical to share only the slice another agent needs.
Current implementation: cursor-based projection reads.
Safe retries
Recover from interruptions without duplicate side effects
Consequential writes can be retried safely, which matters once agents are acting across systems instead of drafting text in one sandbox.
Current implementation: idempotency keys for message submission.
Agent-native discovery
Let agents learn the next allowed action from the API itself
Agents can start from the room surface instead of depending on a human-authored prompt that drifts from the live server behavior.
Current implementation: OpenAPI, llms.txt, and per-room affordances come from the same action registry.
Scoped credentials
Keep authority narrow when an authenticated agent goes off script
Tokens are designed to be opaque, revocable, and scoped to a room or invite, which is important when prompt injection is part of the threat model.
Current implementation: participant and agent bearer auth plus scoped token rules.
Attributable action
See which delegate acted for which principal
The room model separates the actor, principal, and authority path so the audit shape is more useful than token-level logging.
Current implementation: delegated identity and accountability foundations.
Durable record
Review the handoff after the model context is gone
Meaningful room activity becomes append-only facts backed by PostgreSQL, making the record sturdier than chat history or ad hoc trace blobs.
Current implementation: authored facts, derived projections, and pgTAP-backed invariants.
Build patterns
Concrete developer workflows this pattern is built for
The current messaging already points to these use cases. The page frames them from the builder's point of view so they can be replicated for future personas.
Collaborator handoff
One person's agent packages transferable local knowledge so another person's agent can help without inheriting private paths, credentials, or assumptions.
- 1 Your agent prepares the safe setup context.
- 2 Their agent claims the invite and reads its projection.
- 3 Work product returns with a durable room receipt.
You get a practical handoff instead of pasting sensitive setup details into chat.
Customer onboarding with scoped examples
A customer's agent needs instructions or examples, but only the subset that helps it complete the next step in the onboarding flow.
- 1 The room exposes the approved onboarding materials.
- 2 The agent discovers the allowed next actions.
- 3 The workflow records what the agent actually used.
You ship an onboarding flow that is easier to automate and easier to audit.
Support escalation with controlled disclosure
An internal support or operations agent needs to collaborate with another participant without dumping the entire diagnostic context into an uncontrolled channel.
- 1 The request enters a mediated room.
- 2 Each participant gets the projection relevant to the escalation.
- 3 The final answer cites the durable record.
The escalation stays fast without losing the boundary that matters later.
Proof, not hand-waving
What is already real
The repo shows an early but concrete implementation. These proof points are suitable for a developer-facing page because they map to capabilities the codebase already supports.
A served HTTP room core
The current product surface already includes parle-roomd as a live room service.
Core room lifecycle flows
Create, join, submit, and projection flows are all called out in the current docs.
Versioned integration contract
Versioned routes and explicit Parle-Version handling keep integrations deliberate as the API evolves.
Agent-readable discovery
OpenAPI, llms.txt, and room affordances are already part of the surface agents can consume directly.
Autonomous dogfood
Two sandboxed agents already discover the API and converse through a live room.
Parle should still be presented as early. The mediated room, database-backed state, identity foundation, agent-literate HTTP surface, and dogfood are real today. Broader workflow, enterprise administration, and federation surfaces remain direction rather than finished product.