Open Sourcing OpenCaddis and FabrCore: It's Time to Give Back

Standing on the Shoulders of Open Source

I've been a software developer for a long time. Throughout my corporate development career, open source has been a constant — not as a side interest, but as the foundation of nearly everything I've built professionally. The .NET ecosystem I work in every day exists because Microsoft made the decision to open source it. The libraries I reach for — the ORMs, the testing frameworks, the logging systems, the UI components — they're maintained by people who chose to share their work with the world.

I've benefited from that generosity for years. Thousands of hours of other people's work have gone into the tools I use daily. NuGet packages that saved me weeks of development. Stack Overflow answers from contributors who took time to explain things clearly. GitHub repositories with well-written documentation that taught me patterns I still use today.

At some point, you realize the balance sheet is lopsided. You've been withdrawing from the open source community for your entire career, and it's time to make a deposit.

Inspired by OpenClaw

The immediate spark for OpenCaddis was OpenClaw. I'd been following the project, studying how they approached agent architecture, plugin systems, and the patterns they used for command execution and safety. Their Lobster plugin — a pipeline orchestration system — was particularly interesting to me. It demonstrated that AI agents could do more than answer questions; they could execute real workflows with proper safety controls.

OpenClaw showed me what was possible. I'd already been building FabrCore (Fabricate Agent Behavior and Reasoning) since August of 2025 — an engine to manage and orchestrate AI agents in .NET. But OpenClaw inspired me to build something on top of FabrCore that developers could actually use: a full agent workspace that demonstrated what the framework could do. That became OpenCaddis.

FabrCore: The Framework Underneath

FabrCore started as a question: what would an AI agent framework look like if it were designed as a first-class .NET library? Not a Python project with .NET bindings, not a REST API wrapper, but a native .NET framework that uses the patterns .NET developers already know — dependency injection, configuration, logging, async/await, Orleans for distributed state.

FabrCore provides the infrastructure that agent applications need:

• Agent lifecycle management — initialization, health reporting, message processing with OpenTelemetry tracing
• Chat history persistence — thread-based message storage with Orleans grain state, buffered writes, and atomic replacement
• Tool resolution — automatic discovery of tools from dependency injection with the IFabrPlugin interface
• Chat history compaction — automatic LLM-powered summarization to manage context window limits
• Multi-model support — configurable model providers (Azure OpenAI, OpenAI, local models) with named configurations
• Structured output — JSON schema extraction for deterministic LLM responses

The key design decision in FabrCore is the FabrAgentProxy base class. Every agent type — whether it's a simple assistant, a multi-step workflow planner, or an intelligent message router — inherits from this base and gets the full infrastructure for free. Chat persistence, compaction, tool resolution, health reporting, state management. The concrete agent just implements OnInitialize() and OnMessage() and decides what to do with the message.

I needed a way to demonstrate what FabrCore could do. A framework without an application is just documentation — it's hard to evaluate until you see it in action. OpenCaddis became that demonstration.

OpenCaddis: The Application

OpenCaddis is a local AI agent workspace — a Blazor Server application where you create, configure, and interact with multiple AI agents through a chat interface. It runs entirely on your machine. Your conversations, your agent configurations, your vector memories — all stored locally in SQLite. The only external calls are to your configured LLM provider.

It ships with everything a developer needs to be productive:

The goal was to build something that's immediately useful — not a toy demo, but a real workspace that I use daily for research, code analysis, project planning, and email management. It's experimental and expects experienced developers who are comfortable configuring and running .NET applications, but for those who are, it's a powerful starting point.

Why Open Source, Why Now

The honest answer is that I've been meaning to do this for years. Not specifically with AI agents — that's a recent development — but giving something substantial back to the open source community. There's always a reason to wait: the code isn't clean enough, the documentation isn't complete, there are features you want to add first. At some point you have to accept that shipping something useful today is better than shipping something perfect never.

The AI agent space is moving fast, and .NET developers are underserved. Most of the interesting agent frameworks are Python-first. The .NET ecosystem has Microsoft's Semantic Kernel and the emerging Agents SDK, but there's room for more options — especially opinionated, full-stack examples that show how to build a complete agent application, not just call an API.

That's what OpenCaddis and FabrCore offer: a working reference implementation. Not just "here's how to make an LLM call" but "here's how to build a multi-agent workspace with persistent memory, plugin architecture, workflow orchestration, pipeline execution, and chat history compaction — all in .NET, all running locally."

What's in the Box

Here's what you get today:

Both repos have documentation, example configurations, and Docker support. OpenCaddis is published on Docker Hub — you can have it running in under a minute with a single docker run command.

# Try it now
docker run -d -p 5000:5000 --name opencaddis vulcan365/opencaddis:latest

# Or clone and build
git clone https://github.com/vulcan365/OpenCaddis.git
cd OpenCaddis/src/OpenCaddis
dotnet run

What's Next

Open sourcing is the starting point, not the finish line. Both projects are actively developed. In the near term, I'm focused on:

• More agent patterns — new agent types and composition patterns that demonstrate FabrCore's flexibility
• Plugin development guide — making it easy for others to build and share their own plugins
• Additional LLM providers — broadening model support beyond Azure OpenAI and OpenAI
• Community feedback — listening to what developers actually need and adjusting the roadmap accordingly

If you're a .NET developer working with AI, I'd love your feedback. File issues, submit PRs, or just try it out and tell me what works and what doesn't. The best open source projects are shaped by their community, and this one is just getting started.

A Note of Gratitude

To the maintainers of the open source projects I've relied on throughout my career — the ones I've used in production, the ones that taught me patterns I still apply, the ones whose documentation answered my questions at 2 AM — thank you. Your work made my work possible.

To the OpenClaw team specifically — your project inspired this one directly. The ideas, the architecture decisions, the willingness to share your work publicly — it matters more than you probably realize.

OpenCaddis and FabrCore are my way of paying it forward. I hope they're useful to someone the way other people's projects have been useful to me.