Reyn Feature Map¶

Full feature inventory of the Reyn Agent OS, extracted from implementation. Each entry links to its reference or concept documentation.

Visual overview¶

mindmap
  root((Reyn<br/>Agent OS))
    OS Core
      Phase Engine
        Act/Decide loop
        Context build
        Candidate gate
        Phase rollback
      LLM Validation
        JSON contract
        Type-decision check
        Next-phase allowlist
        Artifact schema
        Normalization retry
      Preprocessor
        run_op
        iterate
        validate
        lint_plan
        python
      Postprocessor
        Same step types
        Skill-finish transform
        Step memoization
      Workspace P5
        Artifact storage
        Permission-gated IO
      Crash Recovery
        WAL state log
        Forward-replay resume
        CommittedStep memo
      Event System P6
        113+ event types
        Append-only JSONL
        Replay
    Control IR Ops
      file
      ask_user
      run_skill
      shell
      sandboxed_exec
      web_search
      web_fetch
      mcp
      mcp_install
      lint
      embed
      index_write
      index_query
      recall
      index_drop
      judge_output
    DSL
      skill.md
      phase.md
      artifact YAML
    Stdlib Skills
      chat_compactor
      direct_llm
      eval
      eval_builder
      index_docs
      index_events
      judge_phase
      mcp_install
      mcp_search
      ops_report
      read_local_files
      skill_builder
      skill_importer
      skill_improver
      word_stats_demo
    CLI
      reyn run
      reyn chat
      reyn eval
      reyn skills
      reyn lint
      reyn agent
      reyn topology
      reyn memory
      reyn permissions
      reyn events
      reyn mcp
      reyn secret
      reyn source
      reyn config
      reyn web
      reyn init
    Config
      3-layer cascade
      safety
      cost
      sandbox
      web
      eval
      plan
      chat
      embedding
      voice
      events
      skill_search
      models
    Permissions
      Tier 0-3 model
      4-layer resolution
      Skill declarations
      CLI gates
    Budget and Cost
      Per-agent caps
      Per-chain caps
      Rate limits
      Daily/monthly quotas
    Memory and RAG
      Embedding
      SQLite index
      Recall
      Chat compaction
    MCP
      Transports
      mcp serve
      mcp install
    Web and Protocol
      FastAPI gateway
      WebSocket chat
      A2A protocol
      MCP-over-SSE
      REST API
    Multi-Agent
      Agent registry
      Topology system
      MessageBus
      delegate_to_agent
    Sandbox
      SeatbeltBackend
      LandlockBackend
      NoopBackend
      SandboxPolicy

Feature index¶

OS Core¶

Phase Engine¶

Feature	Description	Documentation
Act/Decide loop	LLM↔op volleys until the LLM emits a transition/finish/abort decision	LLM Output Contract · Principles P3/P4
Context build	Constructs LLM input from phase instructions, current artifact, candidates, and available ops	Context Frame
Candidate gate	LLM picks next phase only from OS-provided candidates (P4)	LLM as Decision Engine
Phase rollback	Revert to predecessor phase when downstream output is rejected	Principles P1/P2

LLM Validation¶

Feature	Description	Documentation
JSON contract	Enforce `control` / `artifact` / `control_ir` envelope structure	LLM Output Contract
Type-decision consistency	`finish` type requires `decision=finish`, `next_phase=null`, etc.	LLM Output Contract
Next-phase allowlist	Transition target must appear in the skill graph candidates	LLM Output Contract · Graph
Artifact schema validation	`data` validated against the target phase's `input_schema`	Artifact YAML
Normalization retry	Minor JSON errors healed before rejecting, up to `llm_max_retries`	LLM Output Contract

Preprocessor¶

Feature	Description	Documentation
`run_op` step	Invoke any Control IR op deterministically before the LLM call	Preprocessor DSL
`iterate` step	Fan-out `run_op` over array field elements	Preprocessor DSL
`validate` step	JSON Schema check on artifact data	Preprocessor DSL
`lint_plan` step	Structural check on plan-shaped artifacts	Preprocessor DSL
`python` step	User function in sandboxed subprocess (safe/unsafe mode)	Preprocessor DSL

Postprocessor¶

Feature	Description	Documentation
Skill-finish transform	Convert LLM `final_output` to caller artifact schema	Postprocessor DSL · Concepts: Postprocessor
Same step types	`run_op` / `iterate` / `validate` / `lint_plan` / `python`	Postprocessor DSL
Step memoization	Skip re-execution on crash resume if step already committed	Postprocessor DSL · Skill Resume

Workspace (P5)¶

Feature	Description	Documentation
Artifact storage	Phase artifacts persisted to `.reyn/artifacts/`	Concepts: Workspace
Permission-gated IO	Paths outside CWD require `file.read` / `file.write` declaration	Concepts: Workspace · Permissions

Crash Recovery¶

Feature	Description	Documentation
WAL state log	`step_started` / `step_completed` / `step_failed` written to JSONL	Skill Resume
Forward-replay resume	`SkillResumeAnalyzer` reconstructs run state from state log	Skill Resume
`CommittedStep` memo	Replay recorded op results on resume without re-invoking	Skill Resume
World-op bypass	Transient ops (web_search, web_fetch) re-execute fresh on resume	Skill Resume

Event System (P6)¶

Feature	Description	Documentation
113+ event types	Complete taxonomy: workflow / phase / LLM / tool / budget / permission / etc.	Events reference · Concepts: Events
Append-only JSONL	`.reyn/events/` per-run files with size/age-based rotation	Events reference
Replay	`reyn events <path>` streams events for audit and debug	reyn events CLI

Control IR Ops¶

All ops are documented in the single reference page: Control IR

Op	Description
`file`	`read` / `write` / `edit` / `delete` / `glob` / `grep` / `regenerate_index`
`ask_user`	Pause phase, collect user answer, re-run same phase
`run_skill`	Invoke sub-skill and return `final_output` artifact
`shell`	Raw shell exec — deprecated, use `sandboxed_exec`
`sandboxed_exec`	`argv` under `SandboxPolicy` via platform-selected backend
`web_search`	DuckDuckGo search — Tier 1, default-allow
`web_fetch`	URL fetch + text extract — Tier 1, default-allow
`mcp`	Call a configured MCP server tool by name
`mcp_install`	Install MCP server from registry with permission gate
`lint`	Run DSL linter on a skill directory
`embed`	Chunk text via LiteLLM embedding model
`index_write`	Write embedded chunks to SQLite backend
`index_query`	Vector similarity search over one indexed source
`recall`	Macro: embed → `index_query` per source → merge top-K
`index_drop`	Destructive source removal — requires approval
`judge_output`	LLM scorer with rubric + threshold + `on_fail` policy

DSL¶

Feature	Description	Documentation
`skill.md` frontmatter	`name` / `entry` / `graph` / `final_output` / `permissions` / `postprocessor` / `search_hints`	Skill frontmatter
`phase.md` frontmatter	`input_schema` / `instructions` / `preprocessor` / `allowed_ops` / `model_class`	Phase frontmatter
Artifact YAML	45 built-in types, JSON Schema Draft 7	Artifact YAML
Graph semantics	Phase transition adjacency list and `end` terminal	Graph
Postprocessor block	Deterministic skill-finish transform declared in `skill.md`	Postprocessor
Preprocessor block	Deterministic phase-entry enrichment declared in `phase.md`	Preprocessor
Topology YAML	Multi-agent topology definition	Topology YAML
Profile YAML	Agent role profile definition	Profile YAML

Stdlib Skills¶

Skill	Description	Documentation
`chat_compactor`	Fold chat history into a rolling summary within token budget	Reference
`direct_llm`	Single-shot LLM fallback for catalogue gaps	Reference
`eval`	Evaluate a skill against test cases via `judge_phase` as judge	Reference
`eval_builder`	Generate an eval spec with test cases and rubric	Reference
`index_docs`	Chunk / embed / index pipeline over file globs	Reference
`index_events`	Index P6 event log with incremental cursor tracking	Reference
`judge_phase`	Score one phase artifact against quality criteria	Reference
`mcp_install`	Guided MCP server install from registry	Reference
`mcp_search`	Natural-language search over MCP registry	Reference
`ops_report`	Execution summary from indexed events for a period	Reference
`read_local_files`	Read project files via MCP and synthesise answers	Reference
`skill_builder`	Scaffold a new skill from a natural-language description	Reference
`skill_importer`	Find and import an external skill with DSL conversion	Reference
`skill_improver`	Iterative skill improvement via eval-plan-apply loop	Reference
`word_stats_demo`	Demo of the `python` preprocessor step pattern	Reference

CLI¶

Command	Description	Documentation
`reyn run`	Execute a skill non-interactively	Reference
`reyn chat`	Interactive multi-turn chat with a named agent	Reference
`reyn eval`	Golden dataset eval, result reports, version regression compare	Reference
`reyn skills`	List skills, show details, validate op/permission consistency	Reference
`reyn lint`	DSL linter for a skill directory	Reference
`reyn agent`	Create and manage named persistent agents	Reference
`reyn topology`	Create and manage communication topologies	Reference
`reyn memory`	CRUD + search + export/import for agent memories	Reference
`reyn permissions`	Inspect and revoke saved approval entries	Reference
`reyn events`	Replay event JSONL files or purge old files by date	Reference
`reyn mcp`	Serve, search, install, and manage MCP servers	Reference
`reyn secret`	Set / list / clear secrets in `~/.reyn/secrets.env`	Reference
`reyn source`	List, describe, and remove indexed RAG sources	Reference
`reyn config`	Show, query, and set effective configuration	Reference
`reyn web`	Start FastAPI + WebSocket gateway server	Reference
`reyn init`	Scaffold `reyn.yaml` and `.reyn/` in current directory	Reference

Config¶

Main reference: reyn.yaml

Block	Description	Documentation
3-layer cascade	user-global / project / project-local + CLI flags	reyn-yaml
`${VAR}` interpolation	Env var expansion in all string fields via `secrets.env`	reyn-yaml § interpolation
`safety`	Loop caps / timeout caps / on-limit policy	reyn-yaml § safety
`cost`	Per-agent / per-chain / daily / monthly token+USD caps	Budget config
`sandbox`	Backend selection (auto/seatbelt/landlock/noop) + `on_unsupported`	reyn-yaml § sandbox
`web`	`web.fetch` SSL `verify_ssl` and `ca_bundle` override	reyn-yaml § web
`eval`	Trace exporters: file / langfuse / otlp / ietf_audit	reyn-yaml § eval
`plan`	`step_max_iterations` / `retry_limit` per plan step	reyn-yaml § plan
`chat`	Compaction trigger / head+tail retention / section token caps	Chat Compaction
`embedding`	Model classes / batch_size / cost_warn_threshold	RAG concepts
`voice`	Whisper model / language / device — optional `reyn[voice]`	Voice concepts
`events`	Rotation size/age + cleanup_period_days	Events reference
`skill_search`	BM25 threshold / top_k for skill catalogue routing	Skill frontmatter
`models`	Class → LiteLLM model string with `extends` chain	reyn-yaml § models
`permissions`	Project-wide default capability policy	Permissions config
`multi-agent`	Agent and topology defaults	Multi-agent config
`state_dir`	Runtime state directory (default `.reyn/`)	State dir

Permissions¶

Feature	Description	Documentation
Tier 0 — always allowed	`run_skill` / `ask_user` / `lint` — no gate	Permission model
Tier 1 — default-allow	`web_search` / `web_fetch` — deny-only gate	Permission model · Permissions config
Tier 2/3 — declaration + 4-layer approval	`shell` / `mcp` / `file` (out-of-zone) / `python`	Permission model
Layer 1: config pre-approval	`reyn.yaml` hard `allow` / `deny`	Permissions config
Layer 2: saved approvals	`.reyn/approvals.yaml` — persisted per path/server	reyn permissions CLI
Layer 3: session approvals	In-memory for current invocation only	Permission model
Layer 4: interactive prompt	Ask user with persist choices (yes / always / just-this-path)	Permission model
Skill-level declarations	`shell` / `file.read+write` / `mcp` / `python` / `mcp_install` / `index_drop`	Skill frontmatter
CLI gates	`--allow-shell` / `--allow-unsafe-python` required at invocation	Common flags

Budget & Cost¶

Feature	Description	Documentation
Per-agent caps	Token + USD hard limits with `warn_ratio`	Budget config
Per-chain caps	Skill spawn count + token total per chain	Budget config
Rate limits	Per-model calls-per-minute sliding window	Budget config
Daily quotas	Persistent JSONL ledger, resets at local midnight	Budget config
Monthly quotas	Persistent JSONL ledger, resets at month boundary	Budget config
`ask_on_exceed`	User-approval extension flow on hard cap hit	Budget config

Memory & RAG¶

Feature	Description	Documentation
LiteLLM embedding backend	Any provider via named model class config	RAG concepts
Batch embed	Configurable `batch_size` with concurrency semaphore	RAG concepts
Dimension table	Static lookup for OpenAI / Voyage / Cohere	RAG concepts
SQLite index per source	`.reyn/index/<source>/index.db` with WAL mode	RAG concepts
Chunk dedup	`content_hash` upsert prevents re-indexing	RAG concepts
`recall` op	embed → `index_query` per source → merge top-K globally	Control IR
Memory CRUD	`list` / `read` / `remember_shared` / `remember_agent` / `forget`	Memory concepts · reyn memory CLI
Chat compaction	head+tail preservation + rolling LLM summary within token budget	Chat Compaction · `chat_compactor`

MCP¶

Feature	Description	Documentation
stdio transport	Subprocess `StdioServerParameters` — implemented	Concepts: MCP
HTTP transport	Streamable HTTP with request headers — implemented	Concepts: MCP
SSE transport	Reserved — raises `NotImplementedError`	Concepts: MCP
`mcp serve`	Expose Reyn agents as an MCP server over stdio JSON-RPC 2.0	reyn mcp CLI
`mcp install`	Fetch from registry, gate permissions, write config, store secrets	mcp_install stdlib · reyn mcp CLI
Secret management	Per-server env vars in `~/.reyn/secrets.env`	reyn secret CLI
Tool dispatch	Lazy-load and cache `MCPClient` per server connection	Concepts: MCP

Web & Protocol¶

Feature	Description	Documentation
FastAPI gateway	REST + WebSocket server on `localhost:8080`	reyn web CLI
WebSocket chat	`/ws/chat` for interactive browser sessions	reyn web CLI
A2A Agent Card	Per-agent `/.well-known/agent-card.json` capability declaration	reyn web CLI
A2A `message/send`	Synchronous JSON-RPC 2.0 single-turn endpoint per agent	reyn web CLI
A2A agent discovery	`GET /a2a/agents` server-level listing	reyn web CLI
MCP-over-SSE	`/mcp/sse` + `/mcp/messages` for MCP client connections	reyn web CLI · reyn mcp CLI
REST API	`/api/*` for agents / skills / runs / topologies / budget / permissions	reyn web CLI

Multi-Agent¶

Feature	Description	Documentation
Agent registry	Named agents with role profiles + `history.jsonl`	reyn agent CLI
`network` topology	Full mesh — any member to any member	Topology YAML · reyn topology CLI
`team` topology	Star around leader — member-to-member forbidden	Topology YAML
`pipeline` topology	Ordered — each member sends only to next	Topology YAML
`_default` topology	Auto-synthesized full mesh for unassigned agents	Multi-agent config
MessageBus	Quiescence-based coordination with `reply_to` correlation	Multi-agent config
`delegate_to_agent`	Async-dispatch to peer with topology permission gate	Concepts: principles P4
Agent hops cap	Max delegation depth via `safety.loop.max_agent_hops`	reyn-yaml § safety
`chain_id` propagation	Trace multi-hop chains in P6 events	Events reference

Sandbox¶

Feature	Description	Documentation
`SeatbeltBackend`	macOS `sandbox-exec` SBPL profile generation	Concepts: Sandbox
`LandlockBackend`	Linux 5.13+ Landlock LSM + seccomp-BPF stacking	Concepts: Sandbox
`NoopBackend`	Fallback audit-only with one-time WARN log	Concepts: Sandbox
`SandboxPolicy`	`network` / `read_paths` / `write_paths` / `subprocess` / `env_passthrough` / `timeout`	Control IR — sandboxed_exec
Auto-selection	Platform detection + `on_unsupported: warn\\|error\\|ignore`	reyn-yaml § sandbox · Concepts: Sandbox