DotCraft: The Project-Scoped .NET Agent Runtime That Lives Inside Your Repo

"Most agents are person-shaped: one chat, one user, one context window that forgets everything tomorrow. DotCraft's bet is that the unit of AI should be the project, not the person — the repo, the Unity build, the client workspace where the real context lives."

Most AI coding agents are built around the individual: you open a chat, you talk to a model, the context lives and dies in that window. DotCraft (GitHub: dotharness/dotcraft), from Singapore-based DotHarness, inverts that. It's a self-hosted, project-scoped agent runtime built on .NET 10 / C# that anchors an AI agent to a project folder — so the Desktop app, the CLI, the TUI, a chatbot, and your own app all share one session core, one set of skills, one memory, and one observability surface. Licensed Apache-2.0, updated as recently as August 17, 2026, it's small (a few hundred stars) but genuinely fresh and on-theme for a blog about AI you run yourself. The honest caveat up front: DotCraft is early. It's the kind of project you watch and pilot, not yet the kind you bet a production pipeline on. But its "project-first" model is a distinctive idea worth understanding — and it slots into the self-hosted-agent conversation next to OpenWorker, hermes-agent, and DeerFlow. This is the breakdown.

1. What DotCraft Is (and Isn't)

DotCraft is not a model and not a SaaS. It's an agent harness — a runtime that takes an LLM (OpenAI-, Anthropic-, or ChatGPT-compatible) and binds it to a project directory with persistence, memory, governance, and multiple entry points. The mental model: instead of "an AI chat that can see your files," it's "an AI agent that lives in your project." Technically it's a C# / .NET 10 application. You can install a Desktop build from GitHub Releases, a CLI/TUI via shell script, or build from source (which needs the .NET 10 SDK and a Rust toolchain). It's licensed Apache-2.0 — a permissive, OSI-approved license that allows commercial use and closed-source integration with attribution. No functional-source-license games here, unlike some peers.

2. The Core Idea: Project-First Workspaces

This is the feature that separates DotCraft from a generic agent wrapper. Every project folder you open becomes its own workspace with a dedicated agent that owns:

• its own conversations and memory,
• its own skills and plugins,
• its own settings and permissions,
• its own observability surface.

The payoff is context depth. Because the agent is bound to the project, it builds a nuanced understanding of that specific repo's structure, conventions, and history — instead of re-deriving context from a fresh prompt every session. For a monorepo with ten services, each service folder can be its own scoped agent with its own memory.

3. Unified Session Model

The "project-first" idea only works if every way you talk to the agent sees the same state. DotCraft's unified session model means the Desktop client, the CLI, the TUI, chatbots, and your own SDK-integrated app all reuse the same execution engine and the same session. Start a conversation on Desktop, continue it in the TUI, pick it back up on Telegram — it's one continuous thread with tool approvals rendered natively on each platform. For a developer, that means you can kick off a research task in the terminal, walk away, and check the result from your phone without losing context. For a team, it means the agent's memory isn't trapped in one person's chat window.

4. Agents, Teams, and Goals

DotCraft gives you three layers of agency:

• Agent Profiles — specialized personas for different kinds of work (e.g., a "reviewer" profile vs a "builder" profile).
• Agent Teams — for a complex request, DotCraft assembles a small team — Explorer, Builder, Reviewer, Operator — led by a Team Leader who splits the work, dispatches it in parallel, and reassembles the result. You hand over one ask; you get a finished mission.
• Goals — a persistent objective you pin to a conversation, with a token or time budget. When the conversation goes idle, DotCraft quietly keeps working toward the goal and pauses/resumes/wraps up on your terms.

The Goals feature is the most interesting: it turns an agent from "responds when I type" into "makes progress while I'm not looking," bounded by a budget so it can't run away. That's a meaningful step toward background agency without a human babysitting every step.

5. Dreams: Background Memory Consolidation

DotCraft's Dreams feature does what the name implies. While you work, it reviews recent activity in the background and drafts memory entries worth keeping — then waits for your approval before committing them. The agent only remembers what you've actually agreed to. This is a clean answer to the "agents that silently accumulate wrong context" failure mode. Memory is proposed, not imposed. You review a queue of dreamt entries at your own pace, approve the useful ones, discard the noise. It's human-in-the-loop memory hygiene, built into the runtime rather than bolted on.

6. Cross-Channel: One Conversation, Any Platform

Because the session model is unified, DotCraft can surface the same agent across channels — Desktop, TUI, and chat platforms including Telegram, WeChat, WeCom, and Feishu, among others. A conversation that starts on your laptop continues on your phone's messenger with native tool-approval prompts on each platform. For a solo developer or a small team, this closes the gap between "the agent on my machine" and "the agent I can poke from anywhere." The governance (approvals, traces, hooks) travels with the conversation, so a mobile approval is as safe as a desktop one.

7. Bring Your Own Model (Including Your Existing ChatGPT Plan)

DotCraft works with any OpenAI- or Anthropic-protocol provider. Two details stand out:

• ChatGPT Plan sign-in. If you already pay for ChatGPT Plus, Pro, Team, Business, or Enterprise, you can sign in with that account and DotCraft runs on the subscription — no separate API key, no extra usage fees. For someone already paying OpenAI, that's effectively free agent runtime.
• Native model support. The docs cite native support for DeepSeek V4 and MiMo V2.5 reasoning models, plus the usual OpenAI/Anthropic endpoints. You route per task.

The ChatGPT-Plan reuse is a clever distribution trick: it lowers the cost barrier to zero for anyone with an existing subscription, while still allowing local or API-based models for privacy-sensitive work.

8. Governance and Observability

An agent that lives in your project needs to be inspectable. DotCraft ships:

• Approvals — sensitive actions prompt before executing.
• Hooks — custom logic at lifecycle points.
• Worktree boundaries — agent edits are scoped so a stray write doesn't silently corrupt your main branch.
• Traces and a Dashboard — every action is logged and viewable, so you can audit what the agent touched after the fact.

None of this is a substitute for not granting an agent root on a production box, but the surface is more mature than a bare agent loop. For a tool this young, shipping approvals + traces + worktrees by default is a good signal.

9. Extensibility: App Binding via SDK

DotCraft exposes an AppServer, SDKs (TypeScript, .NET, Python), and a plugin system so you can wrap your own service into an "App" and plug it straight into the agent. Custom tools, data, and workflows enter the conversation with no extra middleware. Per-tool approval and full audit trails come built in. This is the "make it your platform" on-ramp: instead of the agent being a closed product, your internal services become first-class tools the agent can call, with governance attached. For a company with bespoke internal systems, that's the integration story.

10. The Honest Limitations

DotCraft is early, and the limitations are real. I'm not going to paper over them:

• Small and young. A few hundred stars (204–385 across trackers) as of August 2026. Small community means fewer plugins, fewer war stories, slower issue resolution than established peers.
• .NET 10 requirement. Building from source needs the .NET 10 SDK and a Rust toolchain. If your shop isn't a .NET shop, that's a heavier dependency than a Python or Node tool.
• Provider-dependent. Like every harness, it relies on an external LLM. With ChatGPT sign-in it's cheap; with no model configured it does nothing.
• Learning curve. The project-first + multi-entry-point model is powerful but assumes you'll invest in configuring workspaces, skills, and approvals. It's not zero-config.
• Maturity of docs. As a young project, depth of integration docs and production guidance is thinner than, say, OpenWork or Cognee. Expect to read source.
• Centralized releases. Desktop builds come from GitHub Releases; self-hosting the runtime is straightforward, but there's no managed control plane mentioned — you own the deployment.

Treat DotCraft as a promising pilot, not a production backbone — yet.

11. What It Costs (Real Numbers)

• Software. Apache-2.0 and free to self-host. No license cost.
• Model — ChatGPT Plan. If you sign in with an existing ChatGPT subscription, the agent runs on it: $0 extra. This is the cheapest realistic path.
• Model — API. If you use OpenAI/Anthropic APIs or a local model, you pay that provider's token price. A local Ollama/DeepSeek setup is ~$0 marginal after hardware.
• Build from source. "Free" but costs engineer time for the .NET 10 + Rust toolchain setup.
• Opportunity cost. Configuring workspaces, skills, and approvals is a one-time-per-project investment.

Bottom line: for an individual already paying for ChatGPT, DotCraft is effectively free agent runtime. For a team avoiding subscriptions, local-model mode keeps it at hardware cost only.

12. Where Your Data Lands (Data Sovereignty)

• Project-local by default. The agent's memory, sessions, and config live in the project workspace you open. They're on your machine.
• Model dependency is the asterisk. If you sign in with ChatGPT or use a cloud API, your prompts and context transit that provider — the universal local-AI trade-off. Use a local model (Ollama/DeepSeek via local endpoint) and the whole loop stays on your hardware.
• No mandatory cloud. Unlike tools with a required control plane, DotCraft doesn't force a cloud component. Self-hosted, local-model mode is fully private.
• Cross-channel bots. If you connect Telegram/WeChat, messages flow through those platforms' servers by definition — keep sensitive work off the messenger channels.

Sovereignty verdict: run DotCraft against a local model and it is end-to-end private, with memory stored in your project folder. Attach a hosted model or a chat-platform bot and the relevant text leaves with it — decide per channel.

13. A Real Setup Walkthrough

Say you want DotCraft as the agent for a client's repos: 1. Install. Download the Desktop app from GitHub Releases (or curl -fsSL https://www.dotcraft.net/install.sh | bash for CLI on macOS/Linux). 2. Open the project. Choose the client's repo folder as the workspace. DotCraft initializes a dedicated agent with its own memory. 3. Configure provider. Sign in with your ChatGPT Plan (zero extra cost) or point at a local Ollama endpoint for private work. 4. First request. dotcraft exec "Review this repository and identify the three highest-risk changes." The agent plans, requests approvals, and returns a reviewed list. 5. Background progress. Pin a Goal ("draft migration plan for the auth service, budget 200k tokens") and let it work while you handle other clients; review the Dreams it proposes. 6. Cross-channel. Continue the same conversation from your phone via Telegram when a client calls. Setup time for one project: minutes, if you already have a model configured.

14. DotCraft vs the Field

| | DotCraft | OpenWork | hermes-agent | |---|---|---|---| | Anchor | Project folder | Desktop/team | User/persistent memory | | Language | C# / .NET 10 | TypeScript/Electron | Python | | License | Apache-2.0 | MIT (core) | MIT | | Entry points | Desktop/CLI/TUI/bots/app | Desktop/CLI/web | Desktop/API | | Memory | Dreams (approval-gated) | Session/worker | 4-layer persistent | | Stars (Aug 2026) | ~200–385 | ~19k | ~126k | DotCraft is the smallest of the three by community, but its project-scoped model is the most distinct. OpenWork optimizes for team workflow sharing; hermes-agent optimizes for persistent user memory; DotCraft optimizes for deep project context. Different bets.

15. FAQ

Is it really open source? Yes — Apache-2.0, permissive, commercial use allowed with attribution. Can it run fully offline? Yes, against a local model. No mandatory cloud component. Do my files leave my machine? Only if you use a cloud model or connect a chat-platform bot. Local model = on-prem. Is it production-ready? Not yet — it's early and small. Pilot it; don't bet production on it today. Why .NET? DotHarness is a .NET-ecosystem shop; the harness is built to empower .NET developers with agent infra. If you're a .NET team, that's a plus. Who is it NOT for? Teams that need a large plugin ecosystem, a managed control plane, or battle-tested scale today.

16. Building a Custom App Binding

The SDK is where DotCraft stops being a product and becomes a platform. Using the TypeScript, .NET, or Python SDK, you wrap your own service into an "App" and register it with the agent. That App exposes tools, data, and workflows to the conversation with per-tool approval and full audit trails built in — no extra middleware. Concretely, a company with a bespoke CRM could bind it as an App: the agent gains "look up customer," "open ticket," "summarize account" tools that respect DotCraft's governance. Because the binding is code in your repo, it version-controls like any other integration. For internal-tool-heavy teams, this is the path from "agent that reads files" to "agent that drives our actual systems."

17. Troubleshooting DotCraft

• Build from source fails. You're missing the .NET 10 SDK or the Rust toolchain. Both are required; install per the docs before building.
• Agent does nothing. No provider configured. Sign in with a ChatGPT Plan or set an OpenAI/Anthropic/local endpoint first.
• Edits landed on the wrong branch. You didn't scope a worktree. DotCraft isolates agent edits in worktrees by default — confirm the boundary is active.
• Memory seems stale. Review your Dreams queue; approved entries are what persist. Unapproved dreams don't stick.
• Cross-channel not connecting. The bot integration (Telegram/WeChat/etc.) needs its own credentials and, by design, routes messages through that platform's servers.

18. DotCraft for .NET Teams

DotCraft's .NET 10 foundation is a feature, not a footnote, for the right audience. .NET shops get agent infrastructure in a language and runtime they already operate — no Python/Node stack to stand up just to run an agent. The dotcraft-unity sibling (agent-native Unity Editor integration with in-editor chat and an MCP gateway, powered by Roslyn) extends that to game and simulation teams. For organizations already invested in the Microsoft ecosystem, DotCraft's familiarity lowers adoption friction that a Python tool wouldn't.

19. Roadmap and Community Signals

DotCraft is young but active: the core repo showed commits into late July 2026, with sibling projects (oratorio, a kanban for agent collaboration; dotcraft-plugins, an official plugin registry; dotcraft-unity) all Apache-2.0 and shipping. The pace is early-stage — expect breaking changes and evolving docs. The signal to watch is whether the community grows past a few hundred stars into a real plugin ecosystem; today it's a promising prototype, not a mature platform.

20. Who Should Pilot DotCraft

Pilot it if you are: a .NET team wanting agent infra in your own stack; a developer who likes the "project-scoped agent" model; someone already paying for ChatGPT who wants free agent runtime; a tinkerer comfortable reading source and filing issues. Skip it if you are: needing a large plugin ecosystem or managed control plane today; requiring battle-tested scale and SOC 2 evidence; a non-.NET shop unwilling to take on the .NET 10 + Rust build dependency; a team that can't tolerate pre-1.0 churn. For the right .NET team, DotCraft is a genuinely distinctive bet on project-scoped agency — worth watching closely as it matures.

21. Security Posture for Self-Hosters

Because DotCraft is young, you own more of the hardening than with a mature platform. Practical checklist:

• Don't grant root. Run the agent under a constrained user; scope worktrees so edits can't touch system paths.
• Review Dreams queues. Unapproved memory doesn't persist, but approved memory is trusted by future sessions — audit what you approve.
• Lock down bot channels. Telegram/WeChat messages transit those platforms; keep sensitive work off them and use Desktop/CLI for confidential repos.
• Secrets hygiene. If you sign in with ChatGPT or set an API key, store it outside the project folder and out of version control.
• Network exposure. If you run the host mode on a server, bind it to a private network or VPN; don't expose the agent endpoint publicly without auth.

None of this is unique to DotCraft — it's the standard discipline for any local agent. The tool gives you the primitives (approvals, worktrees, traces); you supply the operational discipline.

22. Goals and Budgets in Practice

The Goals feature is DotCraft's answer to "an agent that makes progress while I'm away." You pin a persistent objective to a conversation and set a budget — either a token cap or a time window. When the conversation goes idle, DotCraft keeps working toward the goal in the background, then pauses, resumes, or wraps up on your signal. A concrete example: pin the goal "Draft a migration plan for the auth service, budget 200k tokens." You close the laptop; DotCraft explores the repo, drafts the plan, and proposes edits — all bounded by the 200k token ceiling so it can't silently burn your whole context budget. When you return, you review what it produced and approve the useful parts. Combined with Dreams (background memory proposals) and Teams (parallel sub-agents), Goals turns DotCraft from a reactive chatbot into a background worker that respects a leash. For solo developers juggling client work, that bounded autonomy is the headline capability.

Related

• OpenWorker: The Local-First Desktop Agent That Ships Results, Not Promises — a more mature desktop-agent comparison point.
• DeerFlow: The SuperAgent Harness That Plans Before It Acts — another orchestrated-agent take.
• hermes-agent: The Persistent-Memory Self-Hosted Agent — memory-focused agent worth contrasting with DotCraft's Dreams.