A AgentWorld

Open platform for strong-agent organizations

Build the operating layer that turns strong agents into durable teams.

Strong agents can already use tools, read files, edit code, and sustain long runs. What they still lack is a shared operating environment. AgentWorld builds that environment through controllers, role-bound skills, organization workspaces, graph execution, and recoverable runtime state.

View Repository Read Architecture
Controllers

Provider-specific sessions, tools, permissions, and streams with one upstream contract.

Organizations

Filesystem-native workspaces with shared memory, local memory, role scopes, and durable artifacts.

Skills

Reusable capabilities attached to operators and roles instead of staying trapped in local prompts.

Runtime

Graph execution, checkpoints, trace, handoff, and resume for long-running multi-agent work.

Claude Code Codex OpenClaw Skill Loading Organization Workspaces Graph Runtime Checkpoint + Resume Open Ecosystem

Mission

The next agent platform is not another wrapper around model calls.

Open ecosystems such as OpenScientist show that reusable skills and shared knowledge can compound across contributors. AgentWorld extends that idea into the platform layer: a place where strong agents can be controlled, equipped, organized, and resumed as members of a persistent system rather than isolated sessions.

From sessions to organizations

A strong agent session is useful. An organization is durable. We want agents to work inside labs, institutes, review boards, and project teams with explicit roles, memory layers, and handoff surfaces.

From hidden state to visible workspaces

Global memory, local memory, long-term records, short-term notes, review queues, and decision logs should live in structured files and folders that both humans and agents can inspect directly.

From private tricks to reusable skills

Skills should outlive one operator run. They should bind to roles, travel with agents, and become a reusable asset across teams, workflows, and future applications.

From demos to recoverable systems

Long-running agent work needs checkpoints, trace, auditability, and resume semantics. That requires a runtime designed for real execution, not just short prompt loops.

Platform

One platform foundation. Multiple growth surfaces.

The graph matters, but it is only one subsystem. The platform has to carry controllers, organization workspaces, skills, coordination, evaluation, and eventually a broader open ecosystem of applications.

01

Controller layer

Encapsulate provider-specific control for Claude Code, Codex, OpenClaw, and future operators while preserving a common upstream contract.

Sessions Tools Streams
02

Organization workspace

Generate file-native institutions with shared memory, local memory, role manifests, inbox artifacts, handoffs, and project spaces.

Global Memory Local Memory Artifacts
03

Skill surface

Load reusable skills per operator and per role so capabilities can compound across runs instead of living inside one-off prompts.

SKILL.md References Scripts
04

Runtime and recovery

Keep graph execution, checkpoint persistence, trace, routing, and resume in a thin runtime that helps strong agents work over durable state.

Graph Checkpoint Resume
AgentWorld platform vision diagram

Runtime

Thin orchestration. Durable execution.

The runtime should do the hard infrastructure work and then get out of the way. It mounts the workspace, prepares operator context, routes execution, preserves state, and keeps runs inspectable.

01

Mount the organization

Create a readable workspace with roles, memory layers, projects, skills, and policy boundaries.

02

Prepare the operator context

Resolve the controller, working directory, skill bundle, inbox artifacts, and current state view.

03

Run and record

Stream provider events, capture outputs, persist checkpoints, and store enough trace to resume later.

04

Route forward

Merge state, place handoffs into the workspace, and continue through graph or organization-level logic.

Current foundation-layer proof
$ python examples/claude_real_smoke.py
plan      tool_call
plan      tool_result
plan      PLAN READY
review    REVIEW READY
status    success
Claude Code Controller Graph Runtime Real Smoke Path

Build

An open build surface for the next generation of agent systems.

The platform grows when different contributors can extend different layers without rewriting the rest. Today that surface already exists in three practical directions.

Integrate a strong agent

Add or improve a controller for a real provider, then let the rest of the stack treat it as one more operator in the system.

Explore controllers

Publish reusable skills

Expand the skill surface so different roles can load different capabilities, references, scripts, and operating guidance.

Explore skills

Build organization templates

Turn the runtime into a platform for labs, institutes, and review boards by defining reusable workspace layouts and organizational roles.

Read the build plan

Status

Implemented where the contracts are hardest.

The repository already contains real controller work, graph execution, per-node skill loading, tests, and CI. The next phase expands the system outward into organization-native runtime and workspace conventions.

Implemented
  • Claude Code control path
  • Graph builder and compiled execution
  • Per-node skill loading
  • Unit tests and CI coverage
Expanding
  • Filesystem-native organization model
  • Workspace memory conventions
  • Durable inbox and handoff artifacts
  • Policy and recovery layers
Open surface
  • New controllers
  • Role-bound skill packs
  • Organization templates
  • Evaluation and benchmark layers
Open GitHub Inspect the Smoke Case