# DotCraft: an embeddable .NET agent runtime from DotHarness

> DotCraft is an Apache-2.0 C#/.NET agent runtime that ships as a desktop app, an embeddable harness package, and an SDK-connected AppServer. It is for .NET teams that want agent features inside their own product rather than a separate chat client.

**DotHarness/dotcraft** — The agent harness for .NET: embeddable, extensible, and ready to use out of the box

- Repository: https://github.com/DotHarness/dotcraft
- Website: https://www.dotcraft.net/
- Stars: 396 · Forks: 19
- Language: C#
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/dotharness-dotcraft

## The gap DotCraft targets in .NET agent work

Most agent tooling arrives as a standalone application or a Python library. A .NET team that wants an agent to plan work, call tools and keep memory across sessions usually ends up writing the orchestration layer itself: prompt assembly, tool registration, conversation storage, model provider switching. DotCraft packages that layer as a runtime and exposes it three ways, which the README describes as Desktop App, AppServer plus SDK, and Harness Package. The intended audience is narrow and specific: developers already inside the .NET ecosystem who want agent behaviour in a service, a desktop tool or an internal automation, and who would rather extend an existing runtime than build one. Teams that only want a chat window over a repository are not the target; the README frames the project as an environment for agents that lives with the workspace, not as a chat product.

## How the runtime, workspace and plugin model fit together

The architecture visible in the README has a single runtime behind several entry points. DotCraft Desktop is one front end; DotCraft.Harness is the same runtime packaged for embedding in .NET applications; AppServer plus SDKs and App Binding let existing products connect to it. State lives with the workspace: the README states that conversations, memory, agents, skills and plugins travel with the project, so moving between Desktop, the CLI, editors and bots does not reset context. Built-in capabilities listed include Plan, Agent Builder, Agent Profiles, Subagents, Automations, Goals, Dreams and Dynamic Workflows. Extension happens through plugins. A .NET plugin uses the same extension model as built-in features and can add tools, prompts, commands and lifecycle logic, and the README states it can be replaced while the host keeps running. Desktop's interface is extended separately through TypeScript and React plugins that use native UI components. The repository layout matches this split: src/, desktop/, sdk/, docker/, docs/, specs/ and tests/ sit side by side, and there are batch scripts such as build.bat, generate-sdk.bat and link-skills.bat at the top level. The README also makes a cost claim worth noting: DotCraft keeps reusable prompt prefixes byte-stable to improve provider cache reuse and lower repeated-input costs. That is a design constraint on prompt construction, not a benchmark result, and the README does not quantify the saving.

## Installing DotCraft and running a first session

There is no NuGet install command in the README. The documented paths are the desktop build and the CLI installer. For the desktop app, the README says to download the latest build from GitHub Releases, open a real project folder as a workspace, then configure model providers and preferences. On macOS and Linux the CLI installs with a shell script:

```bash
curl -fsSL https://www.dotcraft.net/install.sh | bash
```

The Windows PowerShell equivalent is:

```powershell
irm https://www.dotcraft.net/install.ps1 | iex
```

Both scripts are fetched from dotcraft.net, so the install depends on that host being reachable and on the script contents matching the release you expect. After installation, the README points to the Getting Started page for the complete guide. Model access is configured next: DotCraft supports OpenAI and Anthropic providers, or sign-in with a ChatGPT subscription. The README does not document the exact configuration keys for provider setup, so treat the Getting Started page as the source for those values rather than guessing at environment variables. For embedding, the badge section points at the DotCraft.Harness package on NuGet under the DotHarness profile, but the README itself does not show a package reference or a code sample, so check the harness documentation before writing integration code.

## Where DotCraft is the wrong choice

The project is .NET-first, and that is a real constraint rather than a packaging detail. If your stack is JVM, Go or Python, the Harness Package does not help you, and you would be consuming DotCraft through AppServer and an SDK instead, which is a different integration with different failure modes. The release cadence is another consideration: v0.6.2, v0.6.3 and v0.6.4 all landed within four days in September 2026, which suggests interfaces are still being adjusted between patch releases. Anything that plugs into the extension model, a .NET plugin or a TypeScript plugin for Desktop, should be expected to need attention across upgrades. Cost control is also only partly addressed. The byte-stable prompt prefix helps with provider cache reuse, but the README gives no figures, and nothing in it describes spend limits, token budgets or per-workspace quotas. If you need hard cost caps before an agent runs, that is not documented here. Finally, the README does not describe sandboxing or permission boundaries for agent actions, even though the credits list alibaba/OpenSandbox among the projects it thanks. Do not assume isolation from that credit alone.

## How DotCraft differs from assembling microsoft/agent-framework

The closest reference point is microsoft/agent-framework, which DotCraft credits as an inspiration. The difference is in what you receive. Agent Framework is a library you compose: you wire up agents, tools and providers in your own application, and you own the surrounding product. DotCraft ships a runtime with the surrounding product already built: a desktop application, a task board in Oratorio, a remote-folder execution mode in Satellite, and a plugin model that the agent can use to extend its own runtime by creating and building a .NET plugin in the workspace. That is a larger surface with more decisions made for you. It also means more of the upgrade surface belongs to someone else. If you want a small dependency and full control over the agent loop, a framework is the better fit. If you want a working environment for agents over a project folder, plus an embedding path for your own .NET product, DotCraft covers more ground out of the box. The nanobot and codex credits in the README suggest the agent loop and CLI conventions draw on those projects as well.

## Maintenance, releases and the Apache-2.0 licence

The repository is not archived, and the last push was on 2026-09-10, which is recent relative to the v0.6.4 release on 2026-09-08. The version numbering matters more than the activity: at v0.6.x, minor releases can change plugin interfaces and SDK shapes, and the four-day gap between v0.6.2 and v0.6.4 shows how fast patches arrive. Budget for reading release notes before each upgrade, particularly if you maintain a .NET plugin or a TypeScript plugin for Desktop. The licence is Apache-2.0, which permits commercial and closed-source use and includes an explicit patent grant. Two obligations are worth flagging without giving legal advice: you must retain the licence and attribution notices, and the licence includes a patent termination clause. If you modify files, the standard Apache-2.0 practice is to state that you changed them. For a runtime you embed in a shipped product, that is a light obligation compared with copyleft licences, but your own legal review should confirm how it interacts with your distribution model.

## Conclusion

Adopt DotCraft if you are building on .NET and want agent planning, subagents and plugins inside your own application instead of a standalone chat tool, and if you accept that the runtime ships as a NuGet package under Apache-2.0. Do not adopt it if you need a language-neutral runtime, or if you cannot accept a project whose plugin and SDK surface is still moving at a v0.6.x cadence. Before committing, verify on the releases page that a build exists for your platform, check the current NuGet package version of DotCraft.Harness, and read the contributing guide to see how plugin interfaces are versioned.

## FAQ

### What is DotCraft and who is it for?

DotCraft is an open-source, self-hosted AI agent runtime built with C#/.NET. It is aimed at .NET developers who want to run it as a desktop app, embed it in their own application through DotCraft.Harness, or connect existing products through AppServer and SDKs.

### How do I install DotCraft on macOS or Linux?

The README gives a shell installer: curl -fsSL https://www.dotcraft.net/install.sh | bash. Windows PowerShell users run irm https://www.dotcraft.net/install.ps1 | iex, and the desktop app is downloaded from GitHub Releases.

### Which model providers does DotCraft support?

The README states that DotCraft supports OpenAI and Anthropic model providers, or you can sign in using your ChatGPT subscription.

### Can I extend DotCraft with my own plugins?

Yes. The README says a .NET plugin uses the same extension model as built-in features and can add tools, prompts, commands and lifecycle logic, and that it can be replaced while the host keeps running. Desktop's interface is extended separately with TypeScript and React plugins that use native UI components.

### What licence does DotCraft use?

DotCraft is licensed under Apache License 2.0, according to the README and the repository's LICENSE file.

## Sources

- [DotHarness/dotcraft on GitHub](https://github.com/DotHarness/dotcraft)
- [License: Apache-2.0](https://github.com/DotHarness/dotcraft/blob/main/LICENSE)
- [Project website](https://www.dotcraft.net/)
- [README](https://github.com/DotHarness/dotcraft/blob/main/README.md)
- [Releases](https://github.com/DotHarness/dotcraft/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/dotharness-dotcraft
