Autonomous orchestration layer
OSTwin is not about hand-designing a permanent agent for every workflow. It creates the smallest isolated environment an agent needs, records what happens, and turns memory, artifacts, skills, and tool results into better context for the next run.
Users define intent and constraints. OSTwin shapes the runtime around the work instead of asking teams to prebuild every agent personality.
Plans, channel events, decisions, artifacts, and review outcomes become a memory layer that makes future rooms sharper.
Each epic gets its own room, tools, memory view, and evidence trail so the agent has the best local environment without cross-room noise.
The orchestration layer schedules rooms, loads roles and skills, watches signals, and feeds useful outcomes back into the capability system.
Interactive runtime map
Click each node to see how intent becomes a room-scoped environment, how roles and skills act inside it, and how memory feeds the next run.
A markdown plan captures the goal, provider settings, epics, dependencies, acceptance criteria, and the definition of done.
The engine turns epics into a DAG, resolves dependencies, and schedules independent work into executable waves.
Every epic receives a war-room led by a manager role, with its own channel, lifecycle state, artifacts, memory view, and scoped runtime files.
Every role is designed for one side of the loop: Workers create the artifact, while Evaluators inspect it against the epic contract and return actionable feedback.
Skills are focused SKILL.md workflows that load only when the epic and role need that expertise.
MCP servers expose filesystem, memory, channel, and knowledge tools through room-scoped boundaries.
Agents write code, reports, test notes, status messages, and handoff artifacts back into the room.
Digital departments
A team is the durable department above disposable rooms. It owns the charter, manager profile, member roles, event subscriptions, connector target, and data context that let many runs behave like one accountable operating unit.
Department boundary: team-controlled channels, role orchestration, and a scoped operating store.
Composition chain
OSTwin treats agents as short-lived runtime sessions. The durable layer is the capability system around them: skills, memory, search, tools, and performance signals that can move from one room to the next.
SkillOS reasoning flow
OSTwin treats a skill as living operational knowledge: a Worker applies it, an Evaluator tests it, Memory records what happened, and Deep Search grounds what the room cannot know yet.
A plan or role declares skill needs. At room start, OSTwin resolves local, role-scoped, global, and discovered skills into a lean index the agent can inspect without loading every instruction up front.
The Worker uses the current room goal, repo evidence, memory context, and tool surface to select the skill that can move the artifact forward.
The Evaluator reviews behavior against the role contract, test evidence, and acceptance criteria. Feedback is routed through the manager instead of becoming disconnected agent chatter.
Run evidence, review signals, search citations, and memory lineage show where a skill helped or failed. That makes skill updates governable rather than anecdotal.
Deep search lets a skill request outside evidence, lets the Evaluator challenge source quality, and stores the accepted grounding back into Memory for the next room.
Ontology and Knowledge will add a governed concept graph on top of memory, helping agents evolve with project language, dependencies, and domain rules at larger scale.
Quick start
Start small: install the CLI, create a plan, and run it. From there, the documentation branches into plan design, role design, dashboard setup, and runtime reference.
$ curl -fsSL https://twin.igot.ai/installer.sh | bash
$ ostwin plan create —file plan.md
$ ostwin run f055e125de07
room: .agents/war-rooms/EPIC-001
channel: channel.jsonl
state: developingReader routes