Agentic apps from day one

A new kind of software: composable software 2.0, agentic from day one

And it is yours: it runs on your machine, with your data, from files you can commit to your own git.

Why now: the SaaSpocalypse

When agents write code, any product that is not agentic can be copied, rebuilt cheaper, or open-sourced.

Cordis: the plugin kernel under DeepSeek Harness and ACRYL

Cordis began as the plugin kernel of Koishi, a cross-platform chatbot framework (Discord, Telegram, Matrix and more) with more than 4,000 community plugins. It was extracted in 2022 as a meta-framework that knows nothing about LLMs, agents or tools. DeepSeek Harness forked it as @deepseek-ai/cordis and built the whole agent as Cordis plugins: model adapters, tools, sessions, sandboxes, storage and the interface. The design is described in the paper A Programming Paradigm for Spatiotemporal Composability (Peking University and DeepSeek-AI).

Why it exists: the session outlives its parts

A group chat or a coding session runs for days while its capabilities arrive, leave and get replaced. Cordis gives two guarantees so that never breaks the session.

component = requirements + provisions + effects with undo

How it works

A plugin definition, mounted with ctx.plugin(), becomes a Fiber; the Fiber owns its Context, its effects and its child Fibers.

Context: each plugin sees the world through its own ctx; isolate gives two groups their own provider of the same service name.

Fiber lifecycle. PENDING is not an error: the plugin is mounted and waiting for what it injects.

Services and inject: consumers depend on a name; a replaced provider reactivates them.

Events: emit, parallel, serial, bail and waterfall.

Waterfall: each listener wraps the next; next() continues, returning without it answers or vetoes.

Effects: registered 1, 2, 3; reverted 3, 2, 1 when the plugin unloads.

Loader: rows of cordis.patch.yml become the live tree of Fibers.

// a Cordis plugin, simplified: needs the tools service, adds one tool
export const name = 'word-count'
export const inject = ['tools']

export function apply(ctx) {
  ctx.tools.register(defineTool({
    name: 'word_count',
    description: 'Count words in a text',
    parameters: { text: { type: 'string' } },
    async execute({ text }) { return text.split(/\s+/).filter(Boolean).length },
  }))
  // unloading the plugin unregisters the tool: no cleanup code
}

What Cordis does not do

Cordis composes a running process. It does not describe, version or share an app: a profile is a local list of bundles on one machine, nothing pins exact versions and checksums, and there is no registry of whole apps to start from. That gap is why the DeepSeek Harness community already has thousands of plugins that solve the same problems again and again.

ACRYL Blends: a protocol for composable software people can share and reuse

The stack, bottom to top.

# registry/blends/acryl.music/blend.yaml (real)
apiVersion: blends.acryl.dev/v1alpha1
kind: Blueprint
metadata:
  id: acryl.music
  name: Music
  version: 0.1.0
  category: creative
  license: MIT
  visibility: public
spec:
  runtime: cordis
  extends: acryl.blank
  rows:
    - id: brand
      name: acryl-brand
      config: { name: Music, tagline: Say the beat, hear the beat. }
    - id: acryl-music
      name: acryl-music

Why we built it: write a piece once, everyone can reuse it

ACRYL and the open framework run the same packages: @webboxes/blends-core, @webboxes/plugin-hub and @webboxes/app-persistence on npm, MIT.

How it all fits together

Above Cordis everything is plugins in rows. An app, the IDE included, is a choice of rows and their config: a Blend.

The whole map, from the Cordis kernel to the surfaces.

ACRYL IDE is a Blend

The IDE is the Blank core plus IDE plugins plus your own; /blend snapshot shares it like any app.

Three apps, one shape

GTD, Accounting and Music each extend acryl.blank with a brand row and one domain plugin.

One worktree per idea, any coding agent in it

Projects and worktrees

One tree for projects, git worktrees and plain folders. A new branch gets its own worktree and its own chat.

Every agent as a tab

Claude Code, Codex, Grok, GitHub Copilot, OpenCode, Pi and ACRYL's own agent, next to terminal, browser, editor, diff, board and doc tabs.

Review loop

Comment on a line, send it to the agent, review changes and commit in the right panel.

Shared brief

A context document every agent in the workspace reads, whichever tool it is.

Ask for what your workflow lacks; it becomes a plugin, live

Build me a plugin that adds a Pomodoro timer to the top bar: one click starts 25 minutes and shows the time left, another click stops it. Install it so I can use it now.

~90 s button live2 min 45 s whole turn4 files0 restarts

The agent reads ACRYL's plugin documentation, writes the plugin, verifies and installs it, then clicks its own button to test it. In the rehearsal it noticed the button's label changed every second, an accessibility flaw, and fixed it while the timer kept running.

Build a plugin that gives you a tool to list the open issues of any GitHub repository (title, number, labels, age). Install it, then use it to show me the 10 newest open issues of deepseek-ai/deepseek-harness.

2 min 47 s built and used3 files

This time the plugin is a tool for the agent itself, available in every later conversation.

How ACRYL builds a plugin while it runs.

Same framework, very different apps

Each app is a Blueprint in the public registry. Its domain is also a set of agent tools, so the agent operates the app in plain language. The app's own window is its UI, with the agent beside it, and it changes while you watch.

acryl.gtd · Getting Things Done

acryl new my-planner --from acryl.gtdcopy

Capture: call the dentist tomorrow, buy a birthday gift for Anna by Friday, and plan the Vienna talk as a project with three next actions. Ask Marco for the venue access, I'm waiting for him.

45 ssix cards land on the board while you watch

acryl.accounting · invoices, expenses, VAT

acryl new my-books --from acryl.accountingcopy

Add an invoice for ACME, 1200 EUR net, due in 14 days.

4 to 5 s"Which invoices are overdue?" ~5 s"Summarize Q3 VAT" ~5 s

Six agent tools over the app's data. Asking for a CSV export makes the agent write a new plugin with its tests in about two minutes.

acryl.music · a step sequencer

acryl new my-beats --from acryl.musiccopy

Make a 128 bpm techno beat.

Slow it down to 90, take the clap out, and save it as Warehouse.

Add a closed hi-hat track to the drum machine: it should show on the page, make a synthesized hi-hat sound, and be playable with the tools like the other tracks.

5 s operate~2.5 min extend

Real ACRYL Blend apps, running

Each made with acryl new --from from the public registry and run isolated with the real model on 2026-10-19.

Snapshot an app, clone it, it restores itself

The life of a Blend.

{
  "formatVersion": 3,
  "origin": { "id": "app.my-planner", "kind": "Blend" },
  "lineage": { "blueprint": "acryl.gtd", "blueprintVersion": "0.1.0" },
  "parameters": {},
  "modules": [
    { "name": "acryl-quick-notes", "origin": "pulled",
      "version": "0.3.0",
      "spec": "github:inboxxobni/acryl-quick-notes@0.3.0",
      "digest": "sha512-m9bN..." }
  ]
}

The lock records where every plugin came from: a folder inside the app (by content checksum), npm, or a plugin pulled from GitHub (by source and sha512). The same lock format is written by ACRYL and by the acrylblends framework.

One registry for Blends, one for plugins, read live

Both are static indexes on GitHub Pages. acryl.dev/blends and acryl.dev/packages mirror them.

A new agentic app in about three seconds

The agent adds the route as a plugin while the server runs. Node 22.19 or newer; MIT; on npm and GitHub.

95 features built today, in 13 areas

macOS, Windows, Linux · Desktop, Web, terminal

What we are building now

• nextThe Blends page: save, share, and pull another Blend with a diff of every plugin change.
• nextSoftware factory: see every agent session on the machine and hand off in one click. Moving work between Claude Code, Codex and Pi through the shared workspace brief works today.
• nextWorkflows that travel with a Blend: one main agent, worker agents in isolated worktrees, spec-driven.
• nextSettings and workspaces inside a Blend.