One release wave, four products: CritterWatch 1.1 with 83 MCP tools, cron schedules, a Document Explorer and a long list of scalability fixes earned on real systems; Bobcat 1.0, the successor to Storyteller and our answer for spec-driven development; AI Skills 1.17; and the first public preview of Stoat.
AI Skills 1.17 is the result of a review of everything Wolverine, Marten, CritterWatch, Bobcat and Stoat shipped in the last month, checked against the product source rather than the changelogs. Thirty-six skill changes, seven of them correcting advice that had quietly gone wrong, and the CritterWatch 1.1 paired updates that were waiting in 1.16.
Bulk replay that acts on exactly what it counted, edit-and-replay with a full audit trail, every operation followed to the end across every database, and an MCP server that lets an AI agent triage your dead letters, but asks before it deletes anything.
Bobcat is the Critter Stack's new spec-driven integration testing framework, and we have already used it to make our own CI builds and local gating faster and more trustworthy. This is the test automation strategy behind it: fifteen recommendations, and where Bobcat does the job.
Wolverine 6.51 adds a warm-up node role for blue/green deployments: spin up the new release's nodes with no messaging at all, let them rebuild the new versions of your Marten or Polecat projections off to the side, and only cut over once they've caught up. Here's how that fits together with Marten's versioned projections, Wolverine's capability-based agent assignment, and the new side-effect gate, and why a client with a very large system and a habit of revising projections needed all of it.
Wolverine 6.51 adds DurabilityMode.ServerlessWithOutbox so you can write Wolverine handlers in Cloud Run, Lambda, or Azure Functions and still keep the transactional outbox, without any of the always-on background processes a normal Wolverine node depends on. Here's the problem that drove it, how the new mode works, the externally triggered durability pass that recovers anything that didn't get sent, how to receive messages by push, and why Wolverine 6's break from runtime compilation finally makes it a reasonable choice for serverless at all.
How Wolverine's leadership election and agent assignment subsystem grew up: why it exists, what 512 databases and 18,000 agents taught us about reassignment swarms and hysteresis, how we test it now, and a preview of dedicated warm-up nodes for blue/green projection deployments.
Most messaging is about one node handling each message, but sometimes every node needs a copy. Here's how to do that with NATS in a Wolverine application, the new BroadcastToAllNodesAsync() in Wolverine 6.50 that works on any transport, how it fits with Wolverine's SignalR support, and what your options are with Rabbit MQ and the other brokers.
Bobcat went from 0.31 to 0.50 and dropped its Gherkin lane for a projected-only model, WolverineFx.Bobcat shipped, and the whole Event Modeling to specs to scaffolding workflow got a tutorial ahead of tomorrow's live stream. Nineteen pull requests from fourteen people outside JasperFx, headlined by a NATS JetStream hardening pass and a 66 minute leader election brought down to seconds. Plus SQL Server ordered envelope ids, Marten's FetchForWriting consistency fixes, and the LINQ projection surface working under Native AOT.
Wolverine treats the tenant id as message metadata, and that one decision carries the tenant from HTTP detection, into the right Marten, Polecat, or EF Core session, onto every cascaded message, and into the only transactional inbox and outbox in .NET that lives in each tenant's own database. Here's how the whole chain works, and why it took years to get right.
Bobcat is the new Critter Stack tool for Spec Driven Development and for making our own integration testing more reliable. It projects readable specifications out of the xUnit.net or TUnit tests you already have, brings back the table driven testing ideas from Storyteller, reports failures in a way an AI agent can actually use, and has a compiled Gherkin model for when Given/When/Then is the right fit.
Forty releases, 267 merged pull requests, and 38 of those from eleven people outside JasperFx. Native AOT went from aspirational to measured in CI across Marten, Wolverine, Polecat, and Fisher. Weasel picked up a Firebird provider and a pile of MySQL, Oracle, and SQLite fixes from the Quartz.NET maintainer. Wolverine's global partitioning got hardened by a user running it hard in a real cluster. And Polecat and Fisher kept pace with Marten the whole way.
Fisher gets talked about as the Critter Stack's event store on SQLite, but it's also a full document database that lives in a file inside your own process. If SQLite is the right storage for your application, Fisher is a much lower ceremony way to use it than EF Core: no mapping, no migration files, schema changes that just work through Weasel, and a first class Wolverine integration.
If your shop runs on SQL Server and you've been eyeing Event Sourcing, Polecat is the most full featured event store you can get for SQL Server in .NET. It's built on the same shared infrastructure and a decade of production lessons from Marten, it has a first class Wolverine integration for CQRS, CritterWatch can monitor it, and JasperFx Software supports it. Here's the tour.
A fresh git clone, docker compose up -d, and F5. That's the whole onboarding story for a Critter Stack application, and with Wolverine's AutoProvision() it stays that way when you add asynchronous messaging through Rabbit MQ, Amazon SQS, or Azure Service Bus. Here's how the stateful resource model, the resources command, and environment checks make that work.
Bobcat.Supervisor splits a .NET integration test suite across worker processes, isolates each worker's database, retries failures in a fresh process without hiding them, and names the test that hung. It already runs Wolverine's CI and CritterWatch's test gate, and your test project doesn't need to reference Bobcat at all.
CritterWatch 1.1 adds embedded mode — mount the monitoring console inside the Wolverine application you already run, on the PostgreSQL you already have, with no second deployment and no message broker. Two calls, one database, and the console watches the app it lives in.
AI Skills 1.14 ships eight troubleshooting skills that decode Critter Stack exceptions from the stack trace. It's also a good excuse to make the bigger case: skills that know Wolverine's idioms produce terser code, cheaper agent sessions, and an agent that can actually reason through concurrency, parallelism, and production diagnostics.
EF Core query filters and dynamic connection strings are the raw ingredients for multi-tenancy. Wolverine turns them into a finished dish: conjoined tenancy with zero filter plumbing, database per tenant, tenants added at runtime, HTTP tenant detection that flows straight into DbContext construction, a transactional inbox/outbox per tenant database, tenant ids that ride along on every cascaded message, and 'it just works' schema migrations across every tenant database.
A tour of everything in Marten and Wolverine for scaling large event sourced systems: Quick Append, hot/cold event archiving, stream compacting, binary event serialization, read replicas, per-tenant partitioning, database per tenant and sharding, ancillary stores per module, projection lifecycles, strongly consistent async projections, partitioned projection data, and Wolverine-managed projection distribution.
Plenty of .NET messaging tools tell you that ordered processing isn't possible once you scale out. Wolverine gives you a whole range of options, from exclusive single-node listeners to strictly ordered queues to cluster-wide global partitioning, with failover built in.
Polecat, Fisher, and Marten now share one search surface: full-text search, vector similarity search with filters, hybrid search fused by reciprocal rank fusion, and event-sourced vector projections, on SQL Server 2025, SQLite, and PostgreSQL. Here's what each store gives you, how it works, and where they differ.
Wolverine's local queues give modular monoliths in-process messaging that's backed by the transactional inbox, durable against process crashes, fully instrumented with OpenTelemetry and metrics, and tunable for sequencing, partitioning, and circuit breaking. Here's why that makes them a much better fit than MediatR notifications.
Let's get up and running with event sourcing using Marten
WolverineFx.AI adds LLM callouts to Wolverine — one-shot calls to a large language model modeled as ordinary messages, so they get the transactional outbox, retries, back pressure, budgets, and testability for free. The first thing JasperFx is building on it is AI Assisted Production Support in CritterWatch 1.1.
A recorded session pointing an AI agent at a Critter Stack codebase with nothing but the built-in CLI diagnostics and the JasperFx AI Skills — no console, no MCP server, no running fleet. Where is this message routed? What is actually durable? Why isn't the outbox working? And the new projection-run command stepping through a broken projection one event at a time.
Wolverine 6.32 teaches declarative persistence three new places to live — Amazon S3, Azure Blob Storage, and Redis — with conditional-write saga support in each, absorbs the S3 and Azure Blob claim check packages, and adds the explicit [FromMarten] and [FromEfCore] entity attributes for when you want the store named in the code.
A real, recorded session of an AI agent triaging a Wolverine system through CritterWatch's MCP server — summarizing and replaying dead letters, explaining a message's full journey from its OpenTelemetry spans, chasing down a poisoned projection with the projection stepper, and interrogating the alert subsystem. Plus how the JasperFx AI Skills teach the agent to do all of this well.
Weasel manages the schema for every EF Core DbContext in your application the same way it has always managed Marten's -- and its FK-aware database cleaner plus IInitialData give you a fast, repeatable reset between tests. Clean clone to green test suite with no migration chain to run.
Weasel can now generate EF Core migrations from a Weasel schema model or an existing database -- bridging Critter Stack schema management into the standard EF Core migrations workflow.
Weasel is the least-famous member of the Critter Stack, but it's the schema-management and SQL-generation engine underneath Marten and Polecat -- and it just became a shared, dialect-neutral runtime for both event stores.
The Critter Stack's Patching API lets you modify persisted JSON documents in place -- no deserialize, mutate, re-serialize round trip. Here's the shared API across Marten, Polecat, and Fisher, what each database does underneath, and where the three genuinely differ.
CritterWatch 1.0 is watching your system for unusual conditions and trying to explain the cause and effect of anything that's going wrong.
The mechanical half of an NServiceBus migration goes fine unaided. The part that goes wrong is the decision NServiceBus used to make for you -- how each endpoint listens. Here's the same question asked twice, once with the JasperFx AI Skills installed and once without.
NServiceBus and MassTransit have both shipped welcome improvements to their message handler ergonomics. Let's give credit where it's due, then walk through why Wolverine's approach to low ceremony code — no mandatory anything, inlined dependencies, pure function handlers, cascading messages, and readable generated code — is still in a class of its own.
CritterWatch 1.0 is here — a monitoring and production-management console purpose-built for Wolverine, Marten, Polecat, and Fisher. It renders the system you actually shipped from the running code, steps through projections event by event, lets you replay dead letters and rebuild projections without a redeploy, and hands your AI agent a real, RBAC-gated control surface.
Sixty-three releases in sixteen days across Marten, Wolverine, Polecat, Fisher, Weasel, and the shared JasperFx libraries. Fisher brings event sourcing and document storage to SQLite with no server at all, the shared contracts wave means the same Wolverine handler now runs on PostgreSQL, SQL Server, or SQLite without naming a store, and a projection loader bug that silently skipped events makes this an upgrade you should not sit on.
We've run Critter Stack workshops for several teams now, and no two have been the same. One went deep on asynchronous messaging, another on Wolverine's HTTP endpoint and message handler hybrids, a third on using Marten projections to build denormalized views for reporting screens. The material is built and ready — what it turns into depends on what your team actually needs.
Most event sourcing stacks make eventual consistency mandatory: events in one database, read models in another, and a subscription in between. Marten and Polecat keep events and read models in one database, which unlocks a dial no one else offers — projections snapshotted in the same transaction as the events, FetchLatest reads that are accurate even with async projections, wait-for-non-stale queries, and test automation that makes asynchronous projections actually testable.
Every serious event sourced system eventually needs to answer 'what caused this event, and who did it?' The Critter Stack establishes correlation, causation, saga, user, and tenant metadata on Wolverine message envelopes — seeded straight from OpenTelemetry activities — then relays all of it onto the events Marten and Polecat store, with storage you can dial from lean to rich.
Real systems rarely get to standardize on one message broker. Wolverine lets a single application speak Rabbit MQ, Azure Service Bus, Kafka, and MQTT at once — and takes it one step further with a broker-per-tenant model where the tenant id is inferred from the connection a message arrived on and carried all the way into the database transaction.
Seven days, twenty-two releases across Marten, Wolverine, Polecat, Weasel, and JasperFx: a PostgreSQL injection fix under sharded tenancy, two silent data-loss bugs in Wolverine, self-managing time-series partitions, and a big wave of production hardening for projection agent distribution.
Critter Stack services can add, disable, and remove tenants at runtime — new databases and all. CritterWatch turns that capability into an operator console: a tenant lifecycle you can drive from a browser, and performance metrics broken down per tenant id.
The first release candidate for CritterWatch 1.0 — a purpose-built monitoring and operations console for the Critter Stack that shows you the system you actually shipped, watches it for you, hands your AI assistant a real control surface, and gives you a proper cockpit for the event store.
Recent Marten work widens what your LINQ Where/Select expressions translate into PostgreSQL SQL and JSONPath -- so more of your query runs in the database instead of falling back to slower client-side evaluation.
A deep look at the recent hardening of Marten's async projection high water detection -- why an in-flight transaction gap is dangerous, and how transaction evidence keeps projections from ever silently skipping an event.
Mature open-source infrastructure isn't about splashy features -- it's about compounding reliability and measured performance work. Here's how the Critter Stack keeps getting faster and more correct underneath you.
Strict message ordering usually means single-threaded consumers, distributed locks, or a lot of hand-rolled bookkeeping. Wolverine's global partitioning and re-sequencer give you ordered processing across a cluster while still scaling out — no explicit locking required.
CritterWatch 1.0.0-alpha.1 is loose on NuGet — a monitoring and production-management console for Wolverine, Marten, and Polecat that doubles as dev-time insight and an MCP control surface for your AI agents.
Polecat is an event store and lightweight document database for .NET, backed by SQL Server 2025. It brings the proven Marten development model — same IDocumentStore API, projections, and async daemon — to SQL Server shops without a database migration.
The .NET community keeps relitigating Result types vs. exceptions for error handling. With Wolverine you mostly get to opt out of that whole debate — let the framework handle the 404s, the 400s, and the OpenAPI metadata while your code stays clean of both Result wrappers and exception-as-control-flow.
CritterWatch 0.8.0 is the largest release yet — a purpose-built monitoring and operations console for the Critter Stack with production observability, development-time insight, and an MCP control surface built for AI agents.
Why the Critter Stack and Wolverine are the best foundation for vertical slice architecture in the age of AI coding agents — aggressive code compression, locality of reference, and conventions encoded in AI skill files.
Wolverine, the low-ceremony .NET application framework for asynchronous messaging, HTTP endpoints, and CQRS, just passed five million NuGet downloads — with a million in the last six weeks alone.
The Critter Stack 2026 releases have landed: faster cold starts, AOT compliance, better Serverless support, and new greenfield defaults across Marten, Polecat, and Wolverine.
JasperFx Software's officially curated AI Skills for the Critter Stack are now available for purchase — continuously improved guidance that helps AI coding agents write idiomatic Marten, Polecat, and Wolverine code.
Wolverine.HTTP is a first-class HTTP framework for ASP.NET Core built for vertical slice architecture — low ceremony, no Mediator library, built-in transactional outbox, and middleware more powerful than IEndpointFilter.
Wolverine has a strong development and production-time story for EF Core developers — transactional middleware, automatic outbox/inbox, runtime database migrations, test data resets, and declarative persistence.
How to build the most efficient possible HTTP query endpoints in .NET by streaming JSON straight from PostgreSQL with Marten — using Marten.AspNetCore's WriteArray and compiled queries with zero C# allocation.
Polecat is a new JasperFx library that brings Marten's proven Event Sourcing and document database model to SQL Server 2025 — the best technical option for Event Sourcing with SQL Server in .NET.
