ACRYL - Agent Context Relay Yielding Lifecycles

One persistent development environment. One persistent project context. Any coding agent.
Agents may come and go. The work continues.

⭐ Support ACRYL · Website · Documentation · Discord · GitHub

Important

ACRYL is in active early development. Interfaces, workflows, and packaging may change while the first public foundation is established.

What is ACRYL?

ACRYL is an agent-agnostic Agentic Development Environment and continuity layer for software work.

The project does not belong to Claude Code, Codex, OpenCode, Pi, Gemini CLI, DeepSeek, or any other individual agent. ACRYL owns the persistent workspace, project context, tasks, artifacts, and handoffs. Coding agents are replaceable workers that enter and leave the same development scene.

Same project
Same context
Same work
Different agents

ACRYL is being designed to support native and external coding agents through capability-based providers, including:

• Claude Code
• Codex
• OpenCode
• Pi
• Gemini CLI
• DeepSeek Harness native agents
• ACP-compatible agents
• PTY and CLI agents
• future agents that do not know ACRYL exists

Core principles

1. Agent sessions are disposable. Project context is persistent.
2. ACRYL owns continuity. Agents perform work.
3. Canonical state is durable and agent-independent.
4. Agent-specific context is a projection, not the source of truth.
5. Everything practical is a plugin or replaceable capability.
6. Generated capabilities live outside the stable kernel.
7. Every runtime effect must be reversible.
8. Capabilities are versioned, permissioned, testable, and auditable.

Built on Cordis

ACRYL is built around Cordis, the Meta-Framework of Spatiotemporal Composability.

Cordis provides the runtime foundation for:

• lifecycle-managed plugins
• named services and replaceable providers
• reactive dependency injection
• typed events and interception
• reversible effects
• scoped composition and isolation
• configuration-driven application profiles
• hot activation and replacement

This lets ACRYL treat agents, models, memory systems, code graphs, tools, workflows, terminals, and UI surfaces as composable capabilities rather than hardcoded subsystems.

                       ACRYL
                        |
          +-------------+-------------+
          |             |             |
       Desktop         TUI           CLI
          |             |             |
          +-------------+-------------+
                        |
                  ACRYL capabilities
                        |
                      Cordis
                        |
       +----------+-----+-----+----------+
       |          |           |          |
     Agents     Context     Tools       UI

DeepSeek Harness lineage

ACRYL continues important architectural ideas and implementation lessons from DeepSeek Harness, especially its use of Cordis, durable session events, capability seams, agent runtime services, tools, subprocesses, PTYs, sandboxing, and Web UI composition.

DeepSeek Harness is a reference runtime and a reusable substrate, not ACRYL's product identity. ACRYL is an independent project with a broader goal: persistent, cross-agent development continuity. The pinned upstream checkout remains unmodified and isolated in deepseek-harness/.

ACRYL is not affiliated with, authorized by, or endorsed by DeepSeek.

Development Canvas

The Development Canvas is becoming ACRYL's primary working surface. It replaces the main content area with a composable workspace where users can open:

• native PTY terminals
• coding-agent sessions
• files and editors
• browser tabs
• future capability-provided tools and views

The canvas follows the same plugin philosophy as the runtime. UI contributions must control real capabilities and must appear and disappear with their owning plugin lifecycle.

Architecture direction

Persistent ACRYL project
        |
        +-- canonical event stream
        +-- durable tasks and artifacts
        +-- agent identities and sessions
        +-- context projections
        +-- structured handoffs
        +-- workspaces and checkpoints
        |
        +-- Cordis capability graph
              |
              +-- agent providers
              +-- PTY / process providers
              +-- memory providers
              +-- code graph providers
              +-- workflow providers
              +-- UI contributions

The trusted kernel should remain small and stable. New functionality should normally arrive as a versioned capability package that can be validated, activated, observed, and rolled back without rewriting the application core.

Repository layout

dsh-plugin-desktop/     Cordis Host, Client, Electron bootstrap, and Desktop UI
dsh-community-fabric/   Community interoperability RFCs and capability contracts
dsh-community-market/   Community capability-market implementation
deepseek-harness/       Pinned, read-only upstream source submodule
docs/                   Architecture, onboarding, Cordis, and product documentation
assets/                 ACRYL brand assets

Run from source

Requirements

• Node.js ^22.19.0 or >=24.0.0
• Corepack
• Yarn 4.18.0, pinned by the repository

Start ACRYL

git submodule update --init --recursive
corepack yarn install --immutable
corepack yarn dev

Development scripts

Run root package scripts through corepack yarn <script>. Corepack selects the repository-pinned Yarn 4 release; do not use npm run or install dependencies with npm in this workspace.

Daily development session

• corepack yarn dev — recommended local development entry point. It builds dsh-community-market, builds and starts dsh-plugin-desktop, and launches with isolated ACRYL state: DSH_HOME=~/.dsh-acryl plus a separate Electron userData directory. This keeps development profiles and settings away from the installed ACRYL application and seeds advanced mode so Development Canvas is visible.
• corepack yarn dev:local — explicit spelling of dev; use it in notes or automation when the isolated-local behavior should be obvious.
• corepack yarn local — short alias for the same isolated build-and-launch workflow.
• corepack yarn start:local — starts the isolated local application with --skip-build. Use it only when the market and Desktop artifacts are already current; it is faster but can otherwise launch stale output.
• corepack yarn lifecycle — runs the focused development verification suite and launches the isolated application only after it passes. Use this for a verify-then-exercise session.
• corepack yarn dev:shared — builds the market and runs the Desktop package's ordinary development command without the isolated ACRYL home/user-data wrapper. Use it only when intentionally exercising the normal shared profile state.
• corepack yarn start — starts the already-built Desktop package without rebuilding it and without the local isolation wrapper.

Quit an installed DSH Desktop instance before starting a local graphical session, because the installed and development applications may otherwise compete for process or desktop resources.

Build and focused verification

• corepack yarn build — builds the community market first, then the Desktop package that consumes it. Use it to refresh runnable/packageable artifacts.
• corepack yarn typecheck — runs TypeScript checks for Desktop and the community market without emitting build output.
• corepack yarn test — runs the Desktop and community-market unit test suites.
• corepack yarn verify — runs typecheck, test, and the tests for the isolated local launcher. This is the focused gate for an ordinary development session; it is intentionally smaller than the complete repository check.
• corepack yarn test:bilingual-docs — unit-tests the bilingual-document hash and record validator itself.
• corepack yarn check:bilingual-docs — tests that validator and then checks every tracked bilingual pair against its recorded Git blob hashes.
• corepack yarn test:architecture-gates — unit-tests the market dependency direction rules used by the architecture gate.
• corepack yarn check:architecture — runs the architecture-gate tests and verifies the current package dependency direction.
• corepack yarn check:layout — combines bilingual-document and architecture checks with repository-layout verification, including the pinned workspace and upstream boundaries.
• corepack yarn check — runs the complete headless repository gate: check:layout, the Fabric checks, the Market checks, and the full Desktop package check. Use this before handing off or submitting changes.

Packaging and distribution

These commands build the community market first so Desktop packaging consumes current artifacts:

• corepack yarn package:dir — creates an unpacked application directory for inspecting packaged contents without producing a platform installer.
• corepack yarn dist:mac — builds the macOS distribution artifacts.
• corepack yarn dist:mac-smoke — creates the macOS smoke-test package used to validate the local release path.
• corepack yarn dist:win — builds the Windows installer distribution.
• corepack yarn dist:win-portable — builds the portable Windows distribution.

Pinned DeepSeek Harness workspace

The deepseek-harness/ submodule is an independent pnpm workspace. Root wrapper scripts enter it before invoking its pinned pnpm release:

• corepack yarn upstream:update — fetches the remote default branch, verifies it is a fast-forward from the current clean pin, moves the Harness checkout to that exact commit, initializes nested submodules, and synchronizes upstream.json. It refuses to overwrite local Harness or pin-metadata changes. Review the result, then stage deepseek-harness and upstream.json together in a dedicated pin-update commit.
• corepack yarn upstream:version — prints the pnpm version selected inside the upstream checkout; use it to verify the package-manager boundary.
• corepack yarn upstream:install — installs upstream dependencies from its frozen lockfile without converting or modifying the workspace for Yarn.
• corepack yarn upstream:build — runs the upstream Harness build through pnpm.

These wrappers do not authorize edits inside the pinned submodule. Update its pin separately from ACRYL/Desktop behavior changes.

Verify the repository

corepack yarn check

The outer ACRYL workspace uses Yarn. The pinned deepseek-harness/ submodule remains an independent upstream pnpm workspace and must not be edited from an ACRYL feature branch.

Project links

• Website: agentcontextrelay.com
• Documentation: agentcontextrelay.com/docs
• Source: github.com/acryldev/acryl
• Discord: discord.gg/cY9KXMex69
• Cordis: github.com/cordiverse/cordis
• DeepSeek Harness: github.com/deepseek-ai/deepseek-harness

Contributing

ACRYL welcomes contributors interested in agent interoperability, persistent context, Cordis plugins, developer tooling, terminals, editors, dynamic UI, security, and self-extensible software.

Before contributing, read AGENTS.md, the ACRYL orientation, and the Cordis specification.

Join the Discord community to discuss the project and the ACRYL kickoff.

License

ACRYL is licensed under the MIT License.

Acknowledgements

ACRYL builds on the work of the Cordis community and continues architectural inspiration from DeepSeek Harness. We are grateful to both projects and to the broader open-source coding-agent ecosystem.