Six layers
From the person in charge down to a single tool call
Each layer has one job and a narrow interface to the next.
- 01
Oversight layer
Where the workflow owner sees task state, approves sensitive actions, pauses loops and reads reports.
- Approvals
- Sensitive actions stop here until a person says yes.
- Pause
- Any loop can be stopped at any time, from here.
- Reports
- Progress, completion and blockers, in plain language.
- 02
Control plane
Policy, routing and state. Decides which agent handles which task, under which permissions.
- Routing
- Each task goes to the agent suited to it.
- Permission policy
- Checked before every action, not after.
- Recovery
- A restarted run resumes where it stopped instead of repeating work.
- 03
Agent layer
Specialized agents that plan, act and check, handing work to each other with shared state.
- Scoped roles
- Each agent does one kind of job with only the access it needs.
- Handoffs
- Work moves between agents with its context attached.
- Checking
- A separate step verifies results before they move on.
- 04
Memory
Decisions, procedures and prior outcomes, so the system keeps continuity across runs.
- Decisions
- Why something was done is kept next to what was done.
- Procedures
- Agreed ways of working are reused, not reinvented.
- Prior outcomes
- What worked and what failed informs the next run.
- 05
Execution nodes
The machines where agents actually do the work: a computer or server you control, or a cloud worker, agreed per engagement.
- Paired
- A node is explicitly registered before it can take any work.
- Heartbeat
- Each node reports in regularly, so you can see it is online.
- Bounded results
- Nodes return size-limited results, never open-ended data dumps.
- 06
Integration surface
Scoped, logged calls into the tools, APIs and data the workflow already depends on.
- Least privilege
- Each integration gets its own narrowly scoped credential.
- Logged calls
- Every call is recorded with the agent that made it, its scope and outcome.
- Reversible
- Operations are designed so they can be rolled back.
Design rules
Decided once, not per project
Architecture decisions are made at the division level, so no single project reinvents its safety posture. Three of the rules that shape these layers:
Visible while it runs
Task state, approvals and blockers can be seen as the work happens, not only after it finishes.
Traceable and reversible
Every action is logged with the agent that took it and why, and changes are made so they can be rolled back.
Credentials kept out of context
Credentials never enter agent context. Personal data is limited to what a task needs and is not echoed into transcripts or reports.
Data and models
Data, models and access
Which models a system uses and where they run, where memory and logs are stored and for how long, and who can see them are decided per engagement and written down before anything is deployed.
- Model choice and hosting are agreed in Design, not assumed.
- Storage location and retention for memory and logs are set per system.
- Access to a partner's data is limited to the people who need it for the work.
XS1 does not publish its team, partners or research. Qualified partners receive more detail after an initial conversation.
Security review
Need the details for a security review?
We walk qualified partners through architecture, data handling and access after an initial conversation.