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 · Download v0.1.13 · Discord · GitHub

ACRYL has three surfaces that share the same project model, but they are deliberately separate installs. Installing one does not silently install or start the others.

The GitHub Release assets below install the ACRYL Desktop GUI. The app carries the runtime it needs, but it does not add the acryl command to your shell PATH or leave a web server running after the app exits.

Install the terminal interface explicitly:

npm install -g acryl
acryl

The acryl command starts the TUI. It is separate from the Desktop app so terminal users do not need Electron, and desktop users do not receive an unexpected global executable.

Start the browser surface explicitly when you want it:

acryl web

This starts a local ACRYL web runtime, prints its local URL, and serves until you stop the command. It is not a hosted ACRYL cloud service and it does not run in the background by default.

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

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.

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

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.

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.

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.

acryl-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

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

git submodule update --init --recursive
corepack pnpm install --frozen-lockfile
corepack pnpm dev

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

• corepack pnpm dev — recommended local development entry point. It builds dsh-community-market, builds and starts acryl-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 pnpm dev:local — explicit spelling of dev; use it in notes or automation when the isolated-local behavior should be obvious.
• corepack pnpm local — short alias for the same isolated build-and-launch workflow.
• corepack pnpm 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 pnpm 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 pnpm 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 pnpm 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.

• corepack pnpm build — builds the community market first, then the Desktop package that consumes it. Use it to refresh runnable/packageable artifacts.
• corepack pnpm typecheck — runs TypeScript checks for Desktop and the community market without emitting build output.
• corepack pnpm test — runs the Desktop and community-market unit test suites.
• corepack pnpm 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 pnpm test:bilingual-docs — unit-tests the bilingual-document hash and record validator itself.
• corepack pnpm check:bilingual-docs — tests that validator and then checks every tracked bilingual pair against its recorded Git blob hashes.
• corepack pnpm test:architecture-gates — unit-tests the market dependency direction rules used by the architecture gate.
• corepack pnpm check:architecture — runs the architecture-gate tests and verifies the current package dependency direction.
• corepack pnpm check:layout — combines bilingual-document and architecture checks with repository-layout verification, including the pinned workspace and upstream boundaries.
• corepack pnpm 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.

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

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

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

• corepack pnpm 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 pnpm upstream:version — prints the pnpm version selected inside the upstream checkout; use it to verify the package-manager boundary.
• corepack pnpm upstream:install — installs upstream dependencies from its frozen lockfile without converting or modifying the upstream workspace.
• corepack pnpm 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.

corepack pnpm check

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

• 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

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.

ACRYL is licensed under the MIT License.

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.