The modular .NET framework that stays out of your way.
150+ NuGet packages • Abstraction + provider pattern • Explicit infrastructure
Start Here • Package Model • Pick Packages By Job • Quick Start • Packages • Contributing
Headless Framework is a modular .NET framework for APIs and backend services that need production infrastructure without hiding the infrastructure choices. It gives application code stable contracts for common backend concerns, then lets each service choose the concrete provider it will run on.
Use it when a service needs one or more of these building blocks:
- API host defaults: problem details, health endpoints, OpenTelemetry, OpenAPI, forwarded headers, compression, and startup validation.
- Storage-facing abstractions: caching, blob storage, SQL access, dynamic settings, audit logs, permissions, and feature flags.
- Distributed runtime primitives: jobs, messaging, distributed locks, coordination, commit coordination, and dashboards.
- Delivery integrations: email, SMS, push notifications, CAPTCHA, image processing, media indexing, payments, TUS uploads, and serialization.
- Testing support: in-memory providers, test doubles, ASP.NET Core test hosting, and Testcontainers fixtures.
The framework is not a single platform package and it is not an application template. Start application and library code from the abstraction package, then add the core/runtime package and provider package at the service composition root.
Most feature families follow the same shape:
Headless.<Feature>.Abstractions -> contracts application code depends on
Headless.<Feature>.Core -> provider-agnostic runtime and setup builder
Headless.<Feature>.<Provider> -> concrete backend integration
Headless.<Feature>.Testing -> test helpers when the domain has them
That shape keeps provider decisions at the composition root:
- Application code depends on contracts such as
ICache,IBlobStorage,IEmailSender,IDistributedLock,ISettingManager, job managers, or messaging publishers. - Provider packages contribute
UseRedis,UsePostgreSql,UseFileSystem,UseAws,UseAzure, and similar setup members. - Setup is explicit. A service only registers the domains and providers it actually uses.
- Local and test providers are first-class for development, but production behavior still depends on the provider's durability, transaction, ordering, locking, and operational limits.
| Job | Start With | Add When You Need |
|---|---|---|
| API contracts and host defaults | Headless.Api.Abstractions |
Headless.Api.Core or Headless.Api.ServiceDefaults for runnable API hosts |
| Cache contracts | Headless.Caching.Abstractions |
Headless.Caching.Core plus one default provider: in-memory, Redis, or hybrid; add named caches when a service needs multiple stores |
| Blob storage contracts | Headless.Blobs.Abstractions |
Headless.Blobs.Core plus Azure, AWS, Cloudflare R2, filesystem, Redis, or SFTP provider |
| Background job contracts | Headless.Jobs.Abstractions |
Headless.Jobs.Core, Headless.Jobs.SourceGenerator, dashboard, EF Core persistence, and a PostgreSQL or SQL Server native claim provider when contention warrants it |
| Distributed lock contracts | Headless.DistributedLocks.Abstractions |
Headless.DistributedLocks.Core plus in-memory, Redis, PostgreSQL, or SQL Server provider |
| Cluster membership contracts | Headless.Coordination.Abstractions |
Headless.Coordination.Core plus Redis, PostgreSQL, or SQL Server provider |
| Transaction-bound side-effect contracts | Headless.CommitCoordination.Abstractions |
Headless.CommitCoordination.Core plus EF Core, PostgreSQL, SQL Server, in-memory, or durable-work package |
| Dynamic settings contracts | Headless.Settings.Abstractions |
Headless.Settings.Core plus EF Core, PostgreSQL, or SQL Server storage |
| Feature flag contracts | Headless.Features.Abstractions |
Headless.Features.Core plus EF Core, PostgreSQL, or SQL Server storage |
| Permission contracts | Headless.Permissions.Abstractions |
Headless.Permissions.Core plus EF Core, PostgreSQL, SQL Server, or testing provider |
| Audit log contracts | Headless.AuditLog.Abstractions |
Headless.AuditLog.Core plus EF Core, PostgreSQL, or SQL Server storage |
| Email contracts | Headless.Emails.Abstractions |
Headless.Emails.Core plus AWS SES, Azure Communication Services, MailKit SMTP, or dev provider |
| SMS contracts | Headless.Sms.Abstractions |
Headless.Sms.Core plus AWS, Cequens, Connekio, Infobip, Twilio, VictoryLink, Vodafone, or dev provider |
| Push notification contracts | Headless.PushNotifications.Abstractions |
Headless.PushNotifications.Core plus Firebase or dev provider |
| Messaging contracts | Headless.Messaging.Abstractions |
Headless.Messaging.Core, bus/queue abstractions, one transport, one durable storage provider when needed, dashboard, and testing packages |
| Test-only infrastructure | Domain abstraction package | In-memory provider, dev provider, or testing package for that domain |
dotnet add package Headless.Api.ServiceDefaultsvar builder = WebApplication.CreateBuilder(args);
// OpenTelemetry, OpenAPI, problem details, JSON, health checks, forwarded headers,
// compression, exception handling, HSTS, status-code pages, and Headless endpoints.
builder.AddHeadless();
var app = builder.Build();
// Applies the Headless middleware order: forwarded headers, compression,
// status-code/problem-details handling, exceptions, HTTPS/HSTS, and no-cache defaults.
app.UseHeadless();
// Maps Headless operational endpoints such as health, liveness, OpenAPI JSON,
// and static web assets when enabled.
app.MapHeadlessEndpoints();
app.Run();Application code that only consumes a cache should reference Headless.Caching.Abstractions. A runnable host adds the runtime package plus one provider. This example uses the in-memory provider for local development and tests.
dotnet add package Headless.Caching.Abstractions
dotnet add package Headless.Caching.Core
dotnet add package Headless.Caching.InMemorybuilder.Services.AddHeadlessCaching(setup =>
{
setup.UseInMemory();
setup.AddNamed("sessions", cache => cache.UseInMemory());
});Switching to Redis changes the provider package and the setup member, not the consuming code that depends on ICache.
dotnet add package Headless.Caching.Redisbuilder.Services.AddHeadlessCaching(setup =>
{
setup.UseRedis(options =>
{
options.ConnectionMultiplexer =
ConnectionMultiplexer.Connect(builder.Configuration.GetConnectionString("Redis")!);
});
});Use named stores when one application needs several storage backends or several instances of the same backend.
dotnet add package Headless.Blobs.Abstractions
dotnet add package Headless.Blobs.Core
dotnet add package Headless.Blobs.FileSystembuilder.Services.AddHeadlessBlobs(blobs =>
{
blobs.UseFileSystem(options => options.BaseDirectoryPath = "/var/app/blobs");
blobs.AddNamed("scratch", store => store.UseFileSystem(options => options.BaseDirectoryPath = "/tmp/app-blobs"));
});Messaging is one package family, not the framework's center of gravity. Add it when the service has cross-process publish/consume, queues, outbox, delayed delivery, or persisted retry requirements.
Start with:
docs/llms/messaging.mdfor the detailed mental model.demo/Headless.Messaging.Console.Demofor local in-memory wiring.demo/Headless.Messaging.RabbitMq.SqlServer.Demoordemo/Headless.Messaging.Kafka.PostgreSql.Demofor durable examples.
Production use is a composition choice, not a global switch:
- Choose durable providers for state that must survive process restart.
- Use in-memory and dev providers for local development, tests, and isolated demos.
- Prefer named instances when one service talks to multiple logical stores or senders.
- Keep provider configuration at the composition root; do not leak concrete provider clients into business code unless the provider option deliberately exposes an SDK type.
- Read the package README for the domain you install. Each package documents dependencies, side effects, setup requirements, and provider limits.
- Test the actual provider combination used in production when behavior depends on storage, transactions, locks, ordering, broker delivery, or cloud service semantics.
- Most packages target
.NET 10. - Source generator packages target
netstandard2.0. - The repository pins the .NET SDK in
global.json. - Package release notes are published from GitHub releases.
Check release notes before upgrading, especially for configuration APIs, provider setup, storage schema, retry behavior, and source-generated code.
Everything you need to stand up production-grade ASP.NET Core APIs — request/response conventions, validation pipelines, structured logging, and OpenAPI documentation out of the box.
| Package | Description |
|---|---|
| Headless.Api.Core | ASP.NET Core API building blocks (problem details, JWT, identity, middleware) |
| Headless.Api.ServiceDefaults | AddHeadless() orchestrator plus Aspire-style defaults (OpenTelemetry, OpenAPI, service discovery) |
| Headless.Api.Abstractions | API abstractions and contracts |
| Headless.Api.DataProtection | Data protection key storage |
| Headless.Api.FluentValidation | FluentValidation integration for APIs |
| Headless.Api.Logging.Serilog | Serilog logging integration |
| Headless.Api.MinimalApi | Minimal API utilities |
| Headless.Api.Mvc | MVC-specific utilities |
| Headless.Api.Idempotency | Stripe-style HTTP idempotency middleware — cache and replay responses on retries |
Foundational building blocks shared across the framework — domain primitives, DDD base types, guard clauses, and entity/event infrastructure.
| Package | Description |
|---|---|
| Headless.Extensions | Core primitives and utilities |
| Headless.Core | Domain-Driven Design building blocks |
| Headless.Security.Abstractions | Security contracts and options |
| Headless.Security | String encryption and hashing services |
| Headless.Checks | Guard clauses and argument validation |
| Headless.Domain | Domain entities and events |
| Headless.Domain.LocalEventBus | DI-based ILocalEventBus for in-process domain event publishing |
| Headless.Mediator | Mediator pipeline behaviors (FluentValidation, request/response logging) |
| Headless.MultiTenancy | Composition surface for tenant posture across Headless packages |
Property-level audit logging for tracking entity mutations and explicit business events. Records what changed, who changed it, and when — with EF Core persistence.
| Package | Description |
|---|---|
| Headless.AuditLog.Abstractions | Audit log contracts and interfaces |
| Headless.AuditLog.Core | Audit log DI setup, options validation, and provider setup pipeline |
| Headless.AuditLog.Storage.EntityFramework | EF Core audit log persistence |
| Headless.AuditLog.Storage.PostgreSql | PostgreSQL raw audit log storage |
| Headless.AuditLog.Storage.SqlServer | SQL Server raw audit log storage |
Unified blob storage interface with providers for every major cloud and protocol. Store and retrieve files without coupling to any single vendor.
| Package | Description |
|---|---|
| Headless.Blobs.Abstractions | Blob storage interfaces |
| Headless.Blobs.Core | Unified setup builder for composing named blob stores |
| Headless.Blobs.Aws | AWS S3 blob storage |
| Headless.Blobs.Azure | Azure Blob storage |
| Headless.Blobs.CloudflareR2 | Cloudflare R2 (S3-compatible) blob storage |
| Headless.Blobs.FileSystem | Local filesystem storage |
| Headless.Blobs.Redis | Redis blob storage |
| Headless.Blobs.SshNet | SFTP blob storage |
Multi-tier caching with a clean abstraction layer. Supports in-memory, Redis, and hybrid (L1/L2) strategies — swap providers without touching business logic.
| Package | Description |
|---|---|
| Headless.Caching.Abstractions | Caching interfaces |
| Headless.Caching.Core | Shared factory-backed cache orchestration |
| Headless.Caching.Hybrid | Hybrid caching (L1/L2) |
| Headless.Caching.InMemory | In-memory caching |
| Headless.Caching.Redis | Redis caching |
| Headless.Caching.Bcl | Adapter exposing a Headless cache as IDistributedCache |
| Headless.Caching.DistributedLocks | Distributed-lock-backed cache stampede protection |
| Headless.Caching.OutputCache | Backs ASP.NET Core output caching with a Headless cache |
Verify CAPTCHA tokens behind one pass/fail abstraction. Compose Google reCAPTCHA v2/v3 and Cloudflare Turnstile through a single builder — swap or combine providers without touching call sites.
| Package | Description |
|---|---|
| Headless.Captcha.Abstractions | CAPTCHA verification interfaces and builder |
| Headless.Captcha.Core | CAPTCHA setup and validation pipeline |
| Headless.Captcha.ReCaptcha | Google reCAPTCHA v2/v3 provider |
| Headless.Captcha.Turnstile | Cloudflare Turnstile provider |
Send transactional and marketing emails through a unified interface. Plug in AWS SES, SMTP via MailKit, or a no-op dev provider for local testing.
| Package | Description |
|---|---|
| Headless.Emails.Abstractions | Email sending interfaces |
| Headless.Emails.Core | Core email implementation |
| Headless.Emails.Aws | AWS SES email provider |
| Headless.Emails.Azure | Azure Communication Services email provider |
| Headless.Emails.Dev | Development email provider |
| Headless.Emails.Mailkit | MailKit SMTP provider |
Runtime feature flags backed by persistent storage. Toggle features without redeployment and query flag state from anywhere in your application.
| Package | Description |
|---|---|
| Headless.Features.Abstractions | Feature flag interfaces |
| Headless.Features.Core | Feature management implementation |
| Headless.Features.Storage.EntityFramework | EF Core feature storage |
| Headless.Features.Storage.PostgreSql | PostgreSQL raw-DDL feature storage |
| Headless.Features.Storage.SqlServer | SQL Server raw-DDL feature storage |
Identity persistence and storage extensions for ASP.NET Core Identity, built on EF Core.
| Package | Description |
|---|---|
| Headless.Identity.Storage.EntityFramework | EF Core identity storage |
Image processing pipeline with pluggable backends. Resize, crop, convert, and optimize images through a clean abstraction.
| Package | Description |
|---|---|
| Headless.Imaging.Abstractions | Image processing interfaces |
| Headless.Imaging.Core | Core image processing |
| Headless.Imaging.ImageSharp | ImageSharp implementation |
Structured logging utilities and enrichers built on top of Serilog.
| Package | Description |
|---|---|
| Headless.Logging.Serilog | Serilog logging utilities |
Content indexing and metadata extraction for media files — images, video, and documents.
| Package | Description |
|---|---|
| Headless.Media.Indexing.Abstractions | Media indexing interfaces |
| Headless.Media.Indexing | Media indexing implementation |
Reliable distributed message bus with transactional outbox, automatic retries, delayed delivery, and type-safe consumers. 8 transport providers and 3 storage backends — swap the underlying infrastructure without changing application code.
| Package | Description |
|---|---|
| Headless.Messaging.Abstractions | Core messaging interfaces and contracts |
| Headless.Messaging.Bus.Abstractions | Broadcast (pub/sub) publisher contracts |
| Headless.Messaging.Queue.Abstractions | Point-to-point queue publisher contracts |
| Headless.Messaging.Core | Runtime engine: outbox, retries, delayed delivery, consumer orchestration |
| Headless.Messaging.Dashboard | Web UI for monitoring messages, failures, and system health |
| Headless.Messaging.Dashboard.K8s | Kubernetes node auto-discovery for the dashboard |
| Headless.Messaging.Testing | In-process test harness for asserting on published/consumed/faulted messages |
Transports:
| Package | Description |
|---|---|
| Headless.Messaging.RabbitMq | RabbitMQ (AMQP) |
| Headless.Messaging.Kafka | Apache Kafka |
| Headless.Messaging.Aws | AWS SQS + SNS |
| Headless.Messaging.AzureServiceBus | Azure Service Bus |
| Headless.Messaging.Nats | NATS with JetStream |
| Headless.Messaging.Pulsar | Apache Pulsar |
| Headless.Messaging.Redis | Redis Streams queues and Redis Pub/Sub broadcast |
| Headless.Messaging.InMemory | In-memory (dev/testing) |
Storage backends:
| Package | Description |
|---|---|
| Headless.Messaging.Storage.PostgreSql | PostgreSQL message persistence |
| Headless.Messaging.Storage.PostgreSql.EntityFramework | Binds PostgreSQL message persistence to an EF Core context and transactional outbox |
| Headless.Messaging.Storage.SqlServer | SQL Server message persistence |
| Headless.Messaging.Storage.SqlServer.EntityFramework | Binds SQL Server message persistence to an EF Core context and transactional outbox |
| Headless.Messaging.Storage.InMemory | Ephemeral storage (dev/testing) |
Distributed background job scheduling with cron expressions, delayed execution, monitoring dashboard, and OpenTelemetry observability. Source-generated for compile-time safety.
| Package | Description |
|---|---|
| Headless.Jobs.Abstractions | Job scheduling interfaces |
| Headless.Jobs.Core | Job engine: cron, delays, retries, monitoring |
| Headless.Jobs.SourceGenerator | Compile-time code gen for [Jobs]-marked jobs |
| Headless.Jobs.Dashboard | Web UI for job monitoring |
| Headless.Jobs.EntityFramework | EF Core job state persistence; uses optional Headless.Caching.ICache for cron-expression caching |
| Headless.Jobs.EntityFramework.PostgreSql | PostgreSQL atomic claims with FOR UPDATE SKIP LOCKED |
| Headless.Jobs.EntityFramework.SqlServer | SQL Server atomic claims with UPDLOCK, READPAST, and ROWLOCK |
API documentation generation and interactive UIs. Supports NSwag for spec generation, OData query conventions, and Scalar for a modern API explorer.
| Package | Description |
|---|---|
| Headless.OpenApi.Nswag | NSwag OpenAPI generation |
| Headless.OpenApi.Nswag.OData | NSwag OData support |
| Headless.OpenApi.Scalar | Scalar API documentation |
Database access utilities for Entity Framework Core and Couchbase — conventions, seed data, soft deletes, and multi-tenancy support.
| Package | Description |
|---|---|
| Headless.EntityFramework | Entity Framework Core utilities |
| Headless.EntityFramework.CommitCoordination | Opt-in commit coordination for the Headless EF save pipeline |
| Headless.EntityFramework.Messaging | EF Core outbox dispatcher — atomic integration-event writes on save |
| Headless.Couchbase | Couchbase data-access utilities |
Payment gateway integrations for the MENA region. Cash-in (collection) and cash-out (disbursement) flows through Paymob.
| Package | Description |
|---|---|
| Headless.Payments.Paymob.CashIn | Paymob cash-in payments |
| Headless.Payments.Paymob.CashOut | Paymob cash-out payments |
| Headless.Payments.Paymob.Services | Paymob shared services |
Dynamic, database-backed permission system. Define permissions as code, store assignments in EF Core, and query access control at runtime.
| Package | Description |
|---|---|
| Headless.Permissions.Abstractions | Permission system interfaces |
| Headless.Permissions.Core | Permission system implementation |
| Headless.Permissions.Testing | Test-only always-allow permission and authorization doubles |
| Headless.Permissions.Storage.EntityFramework | EF Core permission storage |
| Headless.Permissions.Storage.PostgreSql | PostgreSQL raw-DDL permission storage |
| Headless.Permissions.Storage.SqlServer | SQL Server raw-DDL permission storage |
Send push notifications through Firebase Cloud Messaging with a clean abstraction. Includes a no-op dev provider for local testing.
| Package | Description |
|---|---|
| Headless.PushNotifications.Abstractions | Push notification interfaces |
| Headless.PushNotifications.Core | Unified setup builder for composing named push-notification services |
| Headless.PushNotifications.Dev | Development push provider |
| Headless.PushNotifications.Firebase | Firebase Cloud Messaging |
Coordinate access to shared resources across distributed services.
| Package | Description |
|---|---|
| Headless.DistributedLocks.Abstractions | Distributed locking interfaces |
| Headless.DistributedLocks.Core | Distributed locking implementation |
| Headless.DistributedLocks.Core.Database | Shared relational substrate for database lock providers |
| Headless.DistributedLocks.InMemory | In-process locking |
| Headless.DistributedLocks.PostgreSql | PostgreSQL advisory-lock locking |
| Headless.DistributedLocks.Redis | Redis-based locking |
| Headless.DistributedLocks.SqlServer | SQL Server application-lock locking |
Cluster membership and liveness tracking — know which nodes are alive across a distributed deployment, with pluggable relational and Redis backends.
| Package | Description |
|---|---|
| Headless.Coordination.Abstractions | Membership, liveness, and lifecycle contracts |
| Headless.Coordination.Core | Provider-agnostic membership engine |
| Headless.Coordination.Core.Database | Shared relational substrate for SQL coordination providers |
| Headless.Coordination.PostgreSql | PostgreSQL membership with server-clock liveness |
| Headless.Coordination.Redis | Redis membership via Lua scripts and server time |
| Headless.Coordination.SqlServer | SQL Server membership with guarded writes |
Tie side effects to transaction boundaries — buffer work (outbox dispatch, durable jobs) inside a transaction and drain it atomically on commit, discard it on rollback.
| Package | Description |
|---|---|
| Headless.CommitCoordination.Abstractions | Commit coordination contracts (provider-free) |
| Headless.CommitCoordination.Core | In-process coordinator, ambient stack, and scope factory |
| Headless.CommitCoordination.DurableWork | Base for durable work buffers writing inside the active transaction |
| Headless.CommitCoordination.EntityFramework | Bridges EF Core commit/rollback edges to commit coordination |
| Headless.CommitCoordination.InMemory | In-process signal source for tests and owner-driven flows |
| Headless.CommitCoordination.PostgreSql | PostgreSQL commit coordination registration points |
| Headless.CommitCoordination.SqlServer | Correlates SQL Server commit/rollback signals to scopes |
Pluggable serialization with providers for System.Text.Json and MessagePack. Use the same interface for JSON APIs and binary wire formats.
| Package | Description |
|---|---|
| Headless.Serializer.Abstractions | Serialization interfaces |
| Headless.Serializer.Json | System.Text.Json serializer |
| Headless.Serializer.MessagePack | MessagePack serializer |
Dynamic application settings stored in a database. Change configuration at runtime without redeployment, with caching and change notification support.
| Package | Description |
|---|---|
| Headless.Settings.Abstractions | Dynamic settings interfaces |
| Headless.Settings.Core | Settings management implementation |
| Headless.Settings.Storage.EntityFramework | EF Core settings storage |
| Headless.Settings.Storage.PostgreSql | PostgreSQL raw-DDL settings storage |
| Headless.Settings.Storage.SqlServer | SQL Server raw-DDL settings storage |
Send SMS messages through a unified interface with providers for major regional and global carriers.
| Package | Description |
|---|---|
| Headless.Sms.Abstractions | SMS sending interfaces |
| Headless.Sms.Core | SMS setup builder and provider selection |
| Headless.Sms.Aws | AWS SNS SMS provider |
| Headless.Sms.Cequens | Cequens SMS provider |
| Headless.Sms.Connekio | Connekio SMS provider |
| Headless.Sms.Dev | Development SMS provider |
| Headless.Sms.Infobip | Infobip SMS provider |
| Headless.Sms.Twilio | Twilio SMS provider |
| Headless.Sms.VictoryLink | VictoryLink SMS provider |
| Headless.Sms.Vodafone | Vodafone SMS provider |
Lightweight connection factories for raw SQL access when you need to drop below the ORM. Supports PostgreSQL, SQL Server, and SQLite.
| Package | Description |
|---|---|
| Headless.Sql.Abstractions | SQL connection interfaces |
| Headless.Sql.Core | Default scoped ambient current-connection implementation |
| Headless.Sql.PostgreSql | PostgreSQL connection factory |
| Headless.Sql.SqlServer | SQL Server connection factory |
| Headless.Sql.Sqlite | SQLite connection factory |
Test infrastructure and utilities — base classes, builders, fixtures, and Testcontainers integration for real-database integration tests.
| Package | Description |
|---|---|
| Headless.Testing | Testing utilities and base classes |
| Headless.Testing.AspNetCore | ASP.NET Core integration-test server with time control and DB reset |
| Headless.Testing.Testcontainers | Testcontainers fixtures |
TUS protocol support for reliable, resumable file uploads. Handles large files gracefully with Azure Blob Storage and distributed locking.
| Package | Description |
|---|---|
| Headless.Tus | TUS protocol utilities |
| Headless.Tus.Azure | Azure Blob TUS store |
| Headless.Tus.DistributedLocks | TUS file locking |
Cross-cutting utilities that don't belong to a specific domain — validation extensions, source generators, hosting helpers, geospatial, and more.
| Package | Description |
|---|---|
| Headless.Dashboard.Authentication | Shared authentication for the Jobs and Messaging dashboards |
| Headless.FluentValidation | FluentValidation extensions |
| Headless.Generator.Primitives | Primitive types source generator |
| Headless.Generator.Primitives.Abstractions | Generator abstractions |
| Headless.Hosting | .NET hosting utilities |
| Headless.NetTopologySuite | Geospatial utilities |
| Headless.Primitives | Value objects, result pattern, paging models, and domain primitives |
| Headless.Redis | Redis utilities |
| Headless.Sitemaps | XML sitemap generation |
| Headless.Slugs | URL slug generation |
| Headless.Urls | Fluent URL builder and parser |
Provider packages are ordinary NuGet packages. To add a custom backend, implement the domain abstraction, expose a Use{Provider} setup extension that matches the family builder, and keep concrete provider details at the composition root. See the package README for the closest provider in the same domain before adding a new one.
If your project uses Headless packages, add the following to your AGENTS.md or CLAUDE.md so AI coding agents can fetch the correct documentation on demand:
## Headless Framework
This project uses [Headless .NET Framework](https://github.com/xshaheen/headless-framework).
When working with Headless packages, fetch the docs index:
https://raw.githubusercontent.com/xshaheen/headless-framework/main/docs/llms/index.md
The index lists per-domain docs to fetch as needed.The index contains the framework's agent rules and links to per-domain documentation under docs/llms/.
Contributions are welcome — issues, feature requests, and PRs. See individual package READMEs for package-specific details.