DCENT_ADE: The Sovereign Agentic Development Environment

Alpha. Here Is Exactly Where It Stands.

This page is an announcement, not a download. There is no public release yet and we are not going to dress up a roadmap as a product. DCENT_ADE is in heavy development, most of what follows has been exercised in live testing, and the parts that have not are labelled as such further down this page.

DCENT Space: One Workspace for Human and Agent

Instead of forcing every agent into a hidden background process, DCENT Space exposes real interactive sessions alongside the rest of the project. A persistent tiled layout with recursively split regions, supporting up to sixteen simultaneously visible tabbed regions with horizontal and vertical splitting, resizing, reparenting, collapsing and zooming.

In practice that means one screen can hold Claude Code working the backend, Codex investigating a performance regression, OpenCode operating on a different branch, an ordinary shell running the application, the repository editor showing the affected files, a diff of exactly what changed, Mission Control tracking the objective, Orion watching the whole situation, and the Review surface waiting for the result. That is the difference between using an AI coding tool and operating an agentic development environment.

None of this is a reinvention of the terminal multiplexer, and we are not pretending otherwise. tmux and screen solved tiling and session persistence decades ago and solved them well. What they do not do is know that pane three is an agent, that it is waiting on your approval, and that it has claimed four files another agent is about to touch.

Orion: The Coordination Layer

A fleet of agents is only useful if something can coordinate it. Orion is the long-lived coordination layer built into DCENT_ADE. It is not another coding chatbot. Its job is to understand the surrounding environment — terminals, sessions, tasks, missions, boards, memory, agent status and project state — and to act on it.

> launch four Claude Code instances
> give two of them the frontend work
> ask Codex to investigate the failing test
> what is everyone doing?
> which agent is waiting for me?
> move that task into review
> have another agent inspect the implementation

That block is an interface sketch, not a captured session. We are labelling it because this project has a rule against fabricated telemetry and a screenshot of invented output would break it on the page that explains the rule.

DCENT_ADE already contains the architectural mechanisms for Orion-driven terminal launching and prompt delivery, including session registries and adoption across reloads. The awareness layer is designed to derive states such as busy, idle, awaiting input and finished from actual terminal behaviour rather than from an agent asserting that it is done, then expose those states to both the coordinator and the human. Coordination primitives include boards, missions, mailbox-style communication, claims and memory.

The point is not to remove the human. It is to change what the human spends attention on. Instead of babysitting every agent terminal, you set direction, approve the decisions that carry consequences, review outcomes, and intervene where judgement actually matters.

These are not marketing categories. They are the five disciplines DCENT_ADE is designed around, plus the two loop patterns we run daily. Each has a full reference page: prompt engineering, context engineering, harness engineering, loop engineering, graph engineering, RALPH loops and Gauntlet loops. Start at the hub.

A Control Plane Between Intention and Authority

Security in an agentic environment is a different problem from security in a text editor. An agent may want to read files, write files, execute commands, launch processes, reach credentials, contact a remote model, activate an MCP server, capture the screen, touch Git, or perform something with external side effects. Those are serious capabilities and they deserve a serious boundary.

DCENT_ADE keeps sensitive authority in its native Tauri and Rust host. The interface layer does not receive unrestricted process, filesystem or network access. New capabilities arrive through narrow, validated native commands, and the rule is preserved deliberately: the WebView does not gain general spawn, SQL or fetch authority for convenience. The native connection layer owns the network policy itself — operation definitions, destinations, redirect behaviour, credential handling, response ceilings and classifications.

MCP and external tool servers are treated the same way: a native registration catalog with approval-bound activation, where the registered executable and argument vector belong to the native layer, under working-directory and environment restrictions rather than arbitrary process creation. Where a restriction is not yet enforceable, it is surfaced honestly instead of being described as a security guarantee. Installing a tool should not silently mean handing an opaque process the keys to the machine.

Ordinary local work carries a zero-telemetry policy. No remote fonts, no analytics, no hidden network dependencies. The Data Map exists to surface real network behaviour rather than hide it behind the word privacy. A development tool should not quietly turn your entire source repository into a telemetry feed because you switched on an AI feature. If you want the wider argument, we keep it at the sovereignty hub.

Free, Open, As-Is

Other environments in this category ship a fraction of this feature set and charge premium prices for it. We are not planning any form of gatekeeping. No paid tier, no seat licence, no feature held back for a pro plan, no telemetry sold on the side.

DCENT_ADE is the result of months of testing agentic workflows and building the tooling to operate them. It is offered free and as-is. If you use it commercially, or if you benefit from it in any way at all, we expect a voluntary subscription or donation — expected, never enforced, never checked, never a condition of use. That arrangement only works if people honour it, and it is the same arrangement that keeps the rest of the DCENT suite open.

We also stand on a very large pile of other people shoulders here. The harnesses, the terminal emulators, the model runners, the editor components, the protocol work, the multiplexers that solved tiling long before us. Open source built the foundation this sits on and the only honest way to use it is to give the same thing back.