Agent skill

Orleans

by managedcode in managedcode/dotnet-skills

Design Microsoft Orleans systems from each primitive's purpose and failure model.

MITAuto-check passed

Install Orleans

skills CLI
$ npx skills add managedcode/dotnet-skills --skill orleans -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install managedcode/dotnet-skills orleans --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/managedcode/dotnet-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/catalog/Frameworks/Orleans/skills/orleans .claude/skills/orleans && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
orleans
GitHub stars
486
Token cost
~4.6k tokens
SKILL.md length
2,206 words
Files
16 (incl. references)
Skills in repo
81
Repo updated
First seen
Licence
MIT

At a glance

Design Microsoft Orleans systems from each primitive's purpose and failure model.

  • Works in 3 steps: the business identity that owns the… → the invariant and what must survive… → the required consistency, query shape,…
  • State versus databases
  • SKILL.md covers Diagnostic Output Budget, Start With Purpose, Mental Model and Workflow, plus 8 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Orleans is an agent skill from managedcode/dotnet-skills. Design Microsoft Orleans systems from each primitive's purpose and failure model. USE FOR: grains, digital twins, state versus databases, transactions, messaging, streams, timers, reminders, Durable Jobs, stateless workers, grain services, startup, and hosting. DO NOT USE FOR: other actor stacks, batches, relational-only CRUD, or advice without an Orleans decision. INVOKES: inspect version and topology, choose the primitive, implement, and validate.

Its SKILL.md is about 4.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 16 other files, including reference files (for example `manifest.json`, `references/anti-patterns.md` and `references/configuration-api.md`).

The repository describes itself as: Installable .NET skill catalog and CLI for Codex, Claude Code, GitHub Copilot, and Gemini. The licence is MIT.

When your agent uses it

  • State versus databases
  • Stateless workers
  • : other actor stacks
  • Relational-only CRUD

Example prompts

  • “/orleans”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. the business identity that owns the behavior;
  2. the invariant and what must survive activation or cluster failure;
  3. the required consistency, query shape, acknowledgement, durability, replay, fan-out, and timing.

What it can do on your machine

Read from SKILL.md and the folder at commit 535dd55. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Orleans loads about 4.6k tokens when it runs, and up to ~57k if it reads all its reference files. Until then it costs about 115 tokens; SKILL.md has 2,206 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~115
When it runs · the whole SKILL.md, loaded when a task matches
~4.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~57k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from managedcode/dotnet-skills at commit 535dd55, republished under its MIT licence (© managedcode). 2,206 words, ~4,587 tokens.

Download SKILL.mdSave it as .claude/skills/orleans/SKILL.md (or your agent's skills folder). This skill also uses 15 other files; get the full folder from GitHub.
name
orleans
description
Design Microsoft Orleans systems from each primitive's purpose and failure model. USE FOR: grains, digital twins, state versus databases, transactions, messaging, streams, timers, reminders, Durable Jobs, stateless workers, grain services, startup, and hosting. DO NOT USE FOR: other actor stacks, batches, relational-only CRUD, or advice without an Orleans decision. INVOKES: inspect version and topology, choose the primitive, implement, and validate.

Microsoft Orleans

Diagnostic Output Budget

Keep native test progress and ANSI visible; use the detected runner's supported flags (--progress on --ansi on for MTP/TUnit), not MTP switches on VSTest. Keep console logs at Warning or higher and one concise final summary. Do not replay progress redraws, successful-test output, or Information/Debug/Trace logs into model context. On failure/crash, show only the failing test/resource, root error, and relevant stack frames; deduplicate and cap each diagnostic response at 80 lines / 8 KiB. Never dump entire console/host/browser logs, HTML, TRX, or crash artifacts. Keep necessary artifacts size-bounded outside context, link them, and inspect exact bounded excerpts. Preserve the runner exit code through capture/filtering; disclose truncation. Silence alone does not establish a hang.

Start With Purpose

Do not begin with an Orleans API. First state:

  1. the business identity that owns the behavior;
  2. the invariant and what must survive activation or cluster failure;
  3. the required consistency, query shape, acknowledgement, durability, replay, fan-out, and timing.

Then select the smallest Orleans primitive whose guarantees match those requirements. Reject Orleans when the problem is primarily shared-memory computation, a finite batch, relational querying, or global coordination with few independent entities.

Inspect package versions for version-sensitive work. Orleans 10.3.1 ships Microsoft.Orleans.DurableJobs* and Microsoft.Orleans.Journaling* as 10.3.1-alpha.1; treat them as experimental until that status changes.

Orleans 10.3 makes Newtonsoft storage enforce the type allow-list, changes RPC telemetry keys, and requires custom grain-context activators to apply configurators before construction. Prefer generated/allowed types over permissive JSON and update affected tests, dashboards, and activators together. 10.3.1 services analyzer contract identities and documents placement hints.

Mental Model

  • A grain is a virtual actor with stable identity, behavior, and optional state, not a process, row, DTO, controller, or background job.
  • A grain reference is a location-transparent address. Getting a reference does not create a durable record or prove that an activation exists.
  • An activation is an ephemeral in-memory execution instance. Orleans creates, places, moves, deactivates, and recreates it. Never equate activation lifetime with entity lifetime.
  • A normal grain has at most one activation in the cluster by default and processes turns one at a time. This makes the grain a natural owner of per-identity invariants.
  • A silo hosts activations. Silos form a cluster; external clients or a co-hosted IGrainFactory call grains.
  • Calls are asynchronous messages even when they look like C# method calls. Network failure, timeout, serialization, retries, and duplicate side effects still matter.
  • A grain can model a digital twin when its identity and behavior map to a real or domain entity; that is a use case, not every grain's definition.
  • Orleans gives logical ownership and turn-based execution. It does not make external side effects transactional, turn arbitrary data into a queryable database, or provide exactly-once execution by default.

Workflow

  1. Inspect the solution, Orleans version, hosting topology, grain interfaces, providers, and tests.
  2. Identify domain identities and invariants. Prefer many independent, bounded entities over global coordinator grains.
  3. Choose state, communication, and time-based work from the tables below.
  4. Keep default non-reentrant scheduling and placement until a measured requirement justifies a change.
  5. Configure providers independently and test the failure model the design depends on.

Choose the State Owner

PrimitivePurposeChoose it whenDo not use it as
Activation fieldsFast, temporary state for one activationThe value is derived, cached, disposable, or safe to rebuild after deactivation/failureDurable truth
IPersistentState<T>Durable current state owned by one grain identityThe grain needs a bounded snapshot loaded on activation and explicitly written after commandsA general query database or cross-grain table
External database/repositoryQueryable, indexed, relational, bulk, shared, or externally owned dataThe system needs joins, search, reporting, set-based updates, independent access, or an existing system of recordA replacement for grain ownership when serialized per-entity decisions are still required
Grain plus database/read modelSeparate command ownership from query/storage concernsA grain owns invariants and a small control snapshot while a database owns large records, history, projections, or reportingTwo competing sources of truth without an explicit contract
JournaledGrain<TState,TEvent>Persist domain events and reconstruct stateAudit history, business-event replay, log consistency, or multi-cluster event-sourced replication is a requirementA default persistence choice for ordinary CRUD state
Orleans.Journaling durable statesReplay durable collection/value operations through a journalThe experimental 10.3 journaling model, durable collections, or durable completion state solves a measured needStable default persistence; it is distinct from JournaledGrain business event sourcing
ITransactionalState<T>ACID, serializable all-or-nothing changes across transactional grain stateA short operation must atomically update multiple grain-owned states and compensation is unacceptableLong-running workflows or atomicity with arbitrary external systems
Saga/process managerDurable progress with compensation across steps and external systemsWork is long-running, spans services, waits for events, or cannot share one transactionInstant atomic commit
Grain State Versus a Database

Use grain state for bounded current state and per-identity invariants. Use a database/read model for joins, search, reporting, bulk work, history, shared access, or an external system of record. When using both, define one authority per field and recovery rules.

Never query or mutate another grain's persistence record behind the grain, or expose provider storage as the public query model merely because it uses SQL/Cosmos/Redis. Before using transactions, try one bounded grain owner; use a saga for external effects or long waits. Read references/persistence-api.md for the full boundary.

Choose Communication

PrimitivePurposeChoose it whenFailure/ownership model
Direct grain callTyped request/response to a known logical ownerThe caller needs completion, a result, or an exceptionAt-most-once by default; a timeout does not prove whether the target committed a side effect
IAsyncEnumerable<T>Stream a response within one caller-initiated requestOne caller consumes progressive results with cancellation and backpressureCall-scoped, not pub/sub, not a durable subscription
Orleans streamDecouple producers and consumers across dynamic, long-lived event flowsPub/sub, multiple consumers, provider-backed queues, replay, or durable subscriptions are neededDelivery, ordering, replay, and backpressure depend on the selected provider
Broadcast channelTransient, low-overhead fan-out to implicit grain subscribersAll interested grains need the latest signal and occasional loss/history gaps are acceptableBest-effort, no message storage, no replay; not a persistent stream
ObserverPush callbacks to a connected client or addressable subscriberA UI/client needs live notifications and can resubscribe after reconnectEphemeral and inherently unreliable for clients; expire, unsubscribe, and delete references
One-way requestRemove the response path for a specialized lossy notificationThe sender needs no result, completion, or error and measured response overhead mattersNo acknowledgement and no guarantee the callee received the request
RequestContextFlow small request-scoped metadataTrace, correlation, tenant, or request metadata must follow a call chainNot durable state; metadata does not flow back in responses
Grain call filterApply cross-cutting behavior around callsAuthorization, telemetry, argument/result inspection, or exception conversion spans many grainsKeep domain decisions in grains, not global filters
Grain extensionAttach a runtime/protocol capability to an addressable grainInfrastructure needs an additional interface without changing the domain interfaceAdvanced runtime mechanism; avoid as ordinary domain composition

Prefer a direct call unless decoupling is a requirement. Do not use a stream merely to avoid calling a known target. Do not use broadcast channels for commands, money movement, audit events, or anything that must be replayed. Do not use observers as a durable event bus.

When adding retries, make side effects idempotent. Default Orleans calls are at-most-once only while neither the runtime nor application retries. Retried calls can arrive more than once, and Orleans does not durably deduplicate them for the application.

Show full SKILL.md (968 more words)Show less

Choose Time-Based and Background Work

PrimitivePurposeChoose it whenDo not choose it when
RegisterGrainTimerPeriodic or one-shot work tied to the current activationWork is frequent, local to an active grain, and safe to stop on deactivation or silo failureThe schedule must survive reactivation/restart
ReminderDurable recurring schedule definition associated with a grain identityLow-frequency recurring work must wake the grain after deactivation or cluster restartEvery missed occurrence must be replayed, timing must be precise, or work is high-frequency
Durable JobPersistent one-time future delivery to a target grain with cancellation/retry metadataA delayed command, expiry, notification, or workflow step must execute at least once around a due timeRecurring work, exactly-once side effects, or production work that cannot accept the current alpha package status
[StatelessWorker]Auto-scaled pool of local stateless grain activationsCPU/transform/routing/pre-aggregation work is not tied to one durable entityScheduling or durability; a stateless worker is not a job system
BackgroundServiceContinuous loop owned by each host processA silo/web host must poll or consume an external source and forward work into grainsOne global loop across replicas unless duplicates are safe or externally coordinated
IHostedServiceHost startup/shutdown action or simpler background componentInitialization or bounded host-lifetime work belongs to standard .NET hostingPer-entity durable work
Orleans startup taskFail-fast hook at a specific silo startup stageLegacy/framework integration truly requires Orleans lifecycle orderingGeneral background work; prefer BackgroundService or IHostedService
Silo lifecycle participantOrdered initialization/shutdown of an Orleans componentA provider or runtime service must start at an exact lifecycle stageBusiness scheduling
Grain servicePer-silo, cluster-partitioned runtime support serviceEvery silo hosts a long-lived service and responsibility for grains must be partitioned across silosAn ordinary domain entity, a singleton, or a durable job queue
External scheduler/workflow engineScheduling/orchestration outside OrleansCross-system workflows, cron calendars, human steps, broad operational control, or mature production guarantees dominatePer-grain work already solved by a stable Orleans primitive
Timer, Reminder, or Durable Job

Timer means “while this activation lives”; reminder means “wake this grain on a durable recurring schedule”; Durable Job means “invoke this target once around a future time, at least once.” Reminders persist definitions but miss ticks while the cluster is down. Durable Job handlers must be idempotent, and current alpha.1 packages are an explicit architecture risk.

BackgroundService means one loop per host replica, not one loop per cluster. Use a well-known grain or external lease/leader for one logical collector.

Read references/scheduling-and-services.md before implementing timers, reminders, Durable Jobs, hosted/startup tasks, silo lifecycle participants, or grain services.

Choose Execution and Scaling

PrimitivePurposeDecision rule
Standard grainSerialize behavior for one identityDefault for stateful domain entities and digital twins
[StatelessWorker]Scale fungible work locally and across silosUse when activations are interchangeable and their local state need not agree
[ReadOnly]Permit compatible reads to interleaveUse only when the method cannot mutate grain state or external invariants
[Reentrant]Allow turns from other calls while the grain awaitsUse for call cycles or measured concurrency needs after auditing every invariant
[AlwaysInterleave] / [MayInterleave]Selectively admit interleavingPrefer narrow scheduling exceptions over making the whole grain reentrant
Placement strategy/filterConstrain or optimize activation locationKeep the resource-optimized default unless locality, hardware, zone, compliance, or role requirements are proven
Placement hintSuggest a target silo for activation or migrationChoose an active compatible silo and scope the request-context hint; it does not move an existing activation
Heterogeneous silo/versioningRun different grain sets or versions during rolloutUse explicit compatibility/version selection for safe rolling deployments

Turn-based execution is single-threaded, not magically race-free. Reentrancy allows another turn to run while the first awaits; any state observed before the await can be stale afterward. Avoid blocking calls, .Result, .Wait(), thread-affine work, and unbounded CPU loops on the grain scheduler.

Hosting and Provider Boundaries

Keep concerns separate: clustering discovers silos; the grain directory locates activations; grain/reminder/transaction/job storage persist different records; stream providers carry events while PubSubStore tracks subscriptions; serialization defines wire and persistence compatibility.

In-memory clustering, storage, reminders, streams, Durable Jobs, and journaling are development/test choices unless loss is explicitly acceptable. Configure production providers, credentials, TLS/networking, server GC, graceful shutdown, and health/readiness for the deployment target. In Aspire, declare backing resources in AppHost and register the keyed clients expected by Orleans providers.

Contract and API Rules

  • Keep grain interfaces coarse-grained and asynchronous: Task, Task<T>, ValueTask<T>, or supported IAsyncEnumerable<T>.
  • Cancellation is cooperative, not proof that work did not finish.
  • Use [GenerateSerializer] and stable [Id(N)] values on messages/state. Use [Alias] for durable type identity and [Immutable] only for genuinely immutable values.
  • Never reuse removed field IDs; write state explicitly and propagate storage failures.
  • Bound external calls and use idempotency plus a saga/outbox when state writes and external effects must be reconciled.

Validate the Chosen Guarantees

  • Grain boundaries follow business identity and avoid hot global coordinators.
  • State is bounded, and the grain-state-versus-database choice is explicit.
  • Every time primitive matches activation, recurrence, durability, and delivery requirements.
  • Durable Job handlers/retried commands are idempotent; reminders tolerate missed ticks.
  • Broadcast channels, observers, and one-way calls carry only loss-tolerant signals.
  • Provider-backed tests prove delivery, ordering, replay, and failover claims.
  • Reentrancy tests cover state across await; transactions use transactional storage, [Reentrant], and PerformRead/PerformUpdate.
  • Hosted services are reviewed for per-replica duplication.
  • Production uses persistent providers, multi-silo tests, and observability wherever the guarantee depends on them.

Load References

Open only the references needed for the selected primitive:

Prefer Learn for stable APIs. For Durable Jobs and Orleans.Journaling, use version-tagged package READMEs/public API because Learn does not yet cover them fully.

© managedcode, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 15 other files (references) in catalog/Frameworks/Orleans/skills/orleans of managedcode/dotnet-skills.

  • SKILL.md
  • manifest.json
  • references/anti-patterns.md
  • references/configuration-api.md
  • references/examples.md
  • references/grain-api.md
  • references/grains.md
  • references/hosting.md
  • references/implementation.md
  • references/official-docs-index.md
  • references/patterns.md
  • references/persistence-api.md
  • references/scheduling-and-services.md
  • references/serialization-api.md
  • references/streaming-api.md
  • references/testing-patterns.md

Open the folder on GitHubat commit 535dd55

Compare with similar skills

Orleans next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Orleans compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Orleans this skillmanagedcode/dotnet-skills486—~4.6kAutomated safety check: PassMIT
Author UI Primitivesremix-run/remix33k—~2.5kAutomated safety check: PassMIT
Assistant UI Primitivescompozy/compozy2.8k—~999Automated safety check: PassMIT
Threejs Primitive Reconstructorjasonkneen/tiny-world-builder1.6k—~1.1kAutomated safety check: PassAGPL-3.0
Cesiumjs PrimitivesCesiumGS/cesiumjs-skills189—~7kAutomated safety check: PassApache-2.0
Rust Concurrency Primitiveshashgraph-online/awesome-codex-plugins1.2k—~807Automated safety check: PassMIT

Similar skills

  • Author UI Primitives

    remix-run/remix

    Build idiomatic headless primitives in packages/ui for Remix.

    33k GitHub stars~2.5k tokensUpdated today
    DevelopmentAuto-check passed
  • Guide for assistant-ui UI primitives - ThreadPrimitive, ComposerPrimitive, MessagePrimitive.

    2.8k GitHub stars~999 tokensUpdated today
    Auto-check passed
  • Threejs Primitive Reconstructor

    jasonkneen/tiny-world-builder

    create robust, browser-runnable three.js primitive reconstructions from static low-poly, voxel, isometric, or stylized game-art reference images.

    1.6k GitHub stars~1.1k tokensUpdated today
    Game DevelopmentAuto-check passed
  • Cesiumjs Primitives

    CesiumGS/cesiumjs-skills

    CesiumJS primitives and geometry - Primitive, GeometryInstance, Appearance, BufferPrimitive collections, GeoJsonPrimitive, Billboard/Label/PointPrimitive collections, built-in geometry shapes…

    189 GitHub stars~7k tokensUpdated 23 days ago
    Auto-check passed
  • Rust Concurrency Primitives

    hashgraph-online/awesome-codex-plugins

    Design and review thread-based Rust concurrency with explicit ownership, sharing, and synchronization choices.

    1.2k GitHub stars~807 tokensUpdated today
    DevelopmentAuto-check passed
  • Official

    Review the quality of an agent's tool descriptions, system/agent prompts, or SKILL.md files against current agent-engineering best practices.

    157 GitHub stars~2.3k tokensUpdated today
    AI & LLM EngineeringAuto-check passed

More from managedcode/dotnet-skills

All 81 skills in this repo
  • Analyzer Config

    managedcode/dotnet-skills

    Use a repo-root .editorconfig to configure free .NET analyzer and style rules.

    486 GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • Archunitnet

    managedcode/dotnet-skills

    Use the open-source free ArchUnitNET library for architecture rules in .NET tests.

    486 GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Aspire

    managedcode/dotnet-skills

    Build, upgrade, and operate Aspire 13.5.x C or TypeScript application hosts with the current CLI, AppHost, ServiceDefaults, integrations, dashboard, testing, MCP, and deployment patterns for…

    486 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Aspnet Core

    managedcode/dotnet-skills

    Build, debug, modernize, or review ASP.NET Core applications with correct hosting, middleware, security, configuration, logging, and deployment patterns on current .NET.

    486 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Asynkron Profiler

    managedcode/dotnet-skills

    Use the open-source free Asynkron.Profiler dotnet tool for CLI-first CPU, allocation, exception, contention, and heap profiling of .NET commands or existing trace artifacts.

    486 GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Azure Functions

    managedcode/dotnet-skills

    Build, review, or migrate Azure Functions in .NET with correct execution model, isolated worker setup, bindings, DI, and Durable Functions patterns.

    486 GitHub stars~2.6k tokensUpdated today
    Auto-check passed

Questions about Orleans

What does Orleans do?

Design Microsoft Orleans systems from each primitive's purpose and failure model. Orleans is an agent skill from managedcode/dotnet-skills. Design Microsoft Orleans systems from each primitive's purpose and failure model.

When should I use Orleans?

Orleans fits situations like: state versus databases; stateless workers; : other actor stacks; relational-only CRUD.

How do I install Orleans in Claude Code?

Run `npx skills add managedcode/dotnet-skills --skill orleans -a claude-code`. Or copy the skill folder (catalog/Frameworks/Orleans/skills/orleans in managedcode/dotnet-skills) into .claude/skills/orleans in your project. Claude Code loads it when a task matches its description.

How do I install Orleans in Codex?

Run `npx skills add managedcode/dotnet-skills --skill orleans -a codex`. Or copy the skill folder (catalog/Frameworks/Orleans/skills/orleans in managedcode/dotnet-skills) into .agents/skills/orleans in your project. Codex loads it when a task matches its description.

Can I use Orleans in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add managedcode/dotnet-skills --skill orleans -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/orleans, .gemini/skills/orleans, .github/skills/orleans and .opencode/skills/orleans in your project.

What does Orleans need to run?

SKILL.md names no scripts, command-line tools or credentials: Orleans is instructions for the agent only.

Does Orleans access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Orleans safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Orleans use?

Orleans is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Orleans use?

About 4.6k tokens (SKILL.md is roughly 18k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 52k tokens, read only when the agent opens those files.

What are the alternatives to Orleans?

Skills that share tags, products or a category with Orleans: Author UI Primitives (remix-run/remix, 33k stars), Assistant UI Primitives (compozy/compozy, 2.8k stars), Threejs Primitive Reconstructor (jasonkneen/tiny-world-builder, 1.6k stars) and Cesiumjs Primitives (CesiumGS/cesiumjs-skills, 189 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Orleans?

managedcode (a GitHub organization) maintains it in managedcode/dotnet-skills, which has 486 GitHub stars. The repository holds 81 skills in this directory. The repository was last updated on October 7, 2026.

Source: managedcode/dotnet-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.