English | 简体中文

We build and run the layers under an agent that has stopped being a demo: where it runs, where its work survives, and the rule the code is written by. Five projects carry that work today — two runtimes, one substrate, a plugin layer and a method. Each one exists because something breaks once an agent runs longer than one conversation.

A single Go binary that turns a model into an agent — host it yourself, or run it as a service. The agent loop, the tools, the sandboxes, the channels and the admin dashboard run in one process; SQLite is the default store.

• Any model. OpenAI, Anthropic, DeepSeek, Mistral, Groq, Ollama, OpenRouter or any OpenAI-compatible endpoint, with a per-agent override of the system default.
• Sandboxes that keep their work. E2B or Docker; skills and workspace are hydrated before a tool call, and the sandbox's files are mirrored back to the store after it.
• Channels, not a chat box. Per-agent Telegram, Discord and Slack bots, with sessions isolated per channel and per chat.
• An API an application can call. OpenAI-compatible /v1/chat/completions with streaming, an SSE chat endpoint, MCP servers, a JSON-RPC plugin system, and per-user quotas.
• Cloud-native when it has to be. The Helm chart scales gateways with an HPA, keeps workspace artifacts in object storage (S3, OSS, R2, MinIO) and runs multi-pod over Postgres and Redis. The same build provisions a tenant, meters usage and enforces quotas, so the hosted path is serverless for the customer: nothing to run, billed by usage.

curl -fsSL https://raw.githubusercontent.com/tokenaissance/fastagent/fastagent/install.sh | bash

github.com/tokenaissance/fastagent

The same job at the edge, on Cloudflare Workers and Durable Objects. One Worker hosts the product, the agent session and the sandbox: an AgentSession object runs the Pi harness and keeps the transcript in its own SQLite, while a Sandbox object owns one container per session.

• Durable by construction. Work waits on alarms, not on a request; an evicted object wakes up and resumes the task it was in the middle of.
• Reconnect is a design case. An SSE adapter turns the session's event stream into text/event-stream, with reconnect and backpressure handled at that one boundary.
• One deploy. The TanStack Start app, the durable objects and the container image ship from the same Worker.

Private while it stabilizes — ask in Discord or on WeChat below.

Ephemeral Workspaces over durable shared history. Every agent mounts a complete, writable Workspace over a shared Store without copying the base. It does its work, commits what changed, and goes away; the history stays.

• Every step is a commit. An fs call lands as a Commit directly; a Bash call is mount → run → commit → unmount, and everything the command changed is in that Commit.
• Parallel agents by default. Branch from any Commit, merge when the branch is done, and name the files that must never conflict in /.lww.
• Cheap enough to do constantly. Snapshots share storage: the upstream benchmark keeps 157 snapshots of a real project in 100 MB, 19.9× smaller than Btrfs + zstd.

Open source by Ephemeral AI Lab; we run it under dsh, send fixes upstream, and mirror it here. layerfs.ai · Docs

The host is DeepSeek Harness (dsh), DeepSeek AI's open-source harness. Its model adapter, tool registry, session log and agent loop are all plugins, so capability is added by mounting a bundle beside them — never by forking the harness. That is where our plugin work goes.

Live Excalidraw architecture inside the harness. Ask the agent to draw or refresh the diagram; the scene is pulled through the Excalidraw+ MCP server, stored in the workspace as a real .excalidraw file, and a viewer re-renders it in place — no screenshot, no page refresh.

• Three model tools — excalidraw_refresh, excalidraw_open, excalidraw_export — over the same scene store the view reads.
• One bundle, two surfaces: dsh's own view beside Chat and Trajectory, and, when dsh-better-sidebar is installed, its tab, file viewer and file icon.
• A deterministic Excalidraw→SVG renderer with no @excalidraw runtime dependency; a revision poll re-renders in place. 212 zero-dependency tests.

0.1 is a read-only viewer — pan, zoom, select — and editing stays in Excalidraw.

github.com/tokenaissance/dsh-excalidraw · Install

dsh plugin --profile desktop add <path-to-checkout>

Published under the dsh-plugin topic — how dsh users find plugins.

Four skills decide how everything above is made: how the code is layered, how a workflow becomes an installable skill, and how the interface is designed. The first two are ours; the last two are upstream projects we run and keep in sync.

A decision method, not a scaffold: diagnose first, then layer. Four layers, one dependency direction, and Musk's five-step algorithm to delete over-engineering before it ships.

• Stack-agnostic. The same four-layer model, mapped onto Express, Next.js, Go or Spring instead of a copied template.
• An anti-over-engineering gate. Advice to adopt the complex solution runs question → delete → simplify → accelerate → automate first.
• Decisions that survive. Architecture choices come with L2/L3 documentation skeletons, so a dependency-rule violation is visible at the file header, not buried in imports.

It is the default review skill in our own repositories. github.com/tokenaissance/clean-architecture

A workflow becomes software, not a longer prompt. An SOP, a transcript, an old skill or a script goes in; a package that is discovered, triggered, validated and published comes out.

• Research before creating. It finds the closest existing skills first, then keeps, adapts, rejects or invents — instead of rebuilding a worse wheel.
• Trigger eval, not vibes. Descriptions are tested against real prompts: written too broadly a skill misfires everywhere, too narrowly it never runs. 23 trigger cases and 35 unit tests back the current release.
• Shipping is part of the work. Package validation, README, secret scan, PR, Release, and an install proof that the published package actually installs.

github.com/tokenaissance/fastagent-meta-skill

Design guidance for coding agents, with a shared vocabulary. One skill and 24 commands — polish, audit, critique, distill, bolder, quieter — a PRODUCT.md that records the audience and constraints once, and 61 deterministic detector rules that run without a model.

• Every model was trained on the same SaaS templates: without guidance it produces the same tells — Inter everywhere, purple-to-blue gradients, cards inside cards.
• The rules are checkable rather than a matter of taste: the CLI and browser extension run the detectors with no API key.

github.com/tokenaissance/impeccable · upstream pbakaus/impeccable

A design skill that refuses to look AI-generated. It picks a macrostructure for the brief, dresses it in one of twenty-one themes, and runs 57 slop tests plus a self-critique before handing anything back.

• Four verbs: build (the default), audit, redesign, and study — the last extracts the design DNA of a page you admire instead of pixel-cloning it.
• Two briefs produce two different sites, not colour-swaps of one template.

github.com/tokenaissance/hallmark · upstream Nutlope/hallmark by Together AI

1. Run an agent. Install FastAgent, open http://localhost:18953, add a model.

   curl -fsSL https://raw.githubusercontent.com/tokenaissance/fastagent/fastagent/install.sh | bash
   fastagent

2. Put a filesystem under it. LayerFS × DSH — Ephemeral AI Lab's plugin — gives agents Branches, Workspaces and a shared history.
3. Add a capability instead of a fork. Read the dsh-plugin topic, or start from the plugin above.
4. Use the hosted product. tokenaissance.com is where the same team ships agents for finance and science.

Need help, or want to build with us? We would like to hear from you.

Personal WeChat

Issues and pull requests are welcome on any repository above.