Measured by the Pereira study, University of Minho. Same job in each language.
Tech
Cloud-native AI platform, built on enterprise .NET from day one.
The prompt is the easy part. The hard part is surviving a million MCP calls a week. We built that on .NET 10, Orleans, Aspire, and the Microsoft Agent Framework: today's distributed .NET for virtual actors, typed AI, and cloud-native ops.
The service guarantee behind everything Prostir runs.
Real, fast-growing adoption of the protocol Prostir speaks.
A static Astro build, fast for people and crawlers alike.
The journey
Your idea is one prompt. Production is ten enterprise layers.
Every AI demo looks the same inside ChatGPT. The real gap is between that demo and a customer who keeps paying, and that is where most teams stall. So here is ours, from the compiled floor up to the public URL. Ten layers. Each one is the dull, dependable choice. Each one is a reason someone with no code can still ship a real product.
-
01 The Foundation
.NET 10 and C#: fast, green, compiled.
Every story needs solid ground. Ours is compiled .NET. We did not start with Python or Node, because at scale small differences turn into big bills. A University of Minho study measured the energy each language burns for the same task. C# uses about 3× the energy of raw C. Python uses about 76×. So one job in Python can burn the energy, and the carbon, of roughly twenty-four .NET servers. Multiply that across a fleet of 18,000 public MCP servers and the language you choose becomes your cloud bill and your climate bill at once. Safety matters too. The npm and PyPI worlds are huge, and supply-chain attacks hit them again and again. NuGet is smaller, signed, and a far smaller target. So C# is the greenest, and one of the safest, lines of code on this page, and ASP.NET Core stays near the top of every TechEmpower speed test.
-
02 The Cloud
Azure: enterprise-grade, compliant, global.
A demo runs on a laptop. A product a stranger pays for has to run somewhere a regulator, a hospital, and a CFO all trust. That is Azure. It carries the broadest compliance list in the cloud: GDPR, HIPAA, SOC, ISO 27001, PCI DSS, FedRAMP. It backs the services Prostir uses with uptime guarantees up to 99.99%. Your agent and its data live in the region you pick, in the EU or the US, and Azure's global network keeps them close to your customers. You wire up no datacenters yourself. Compliance, uptime, and reach are not things you add later. They are where a paid product has to start.
-
03 The Local Bridge
Aspire: one AppHost, real integration tests.
Mocks lie. Aspire does not. One file, the Prostir.AppHost, wires together Cosmos DB, Azure Storage, the Orleans cluster, the API, the MCP gateway, and the operator console. The same setup runs on your laptop, in CI, and in the cloud. Our tests run against the real services Aspire starts, never against fakes. That is the only way a codebase an AI helped write stays honest. If it passes here, it passes in production, because here and production are the same wiring.
-
04 The Distributed Runtime
Orleans: every agent gets a digital twin.
Here is the one idea that makes the rest simple. Orleans gives every agent a virtual actor. Think of it as a digital twin: a software copy of a real thing, an agent, a customer, that keeps its own memory and does its own work in its own sealed room, untouched by anyone else. Once everything is a twin, the work stops being about servers and becomes about objects talking to each other. You just describe who sends what message to whom: a person to a twin, a twin to another twin. That is the whole model. It is old and proven. Erlang ran phone networks this way for decades with almost no downtime. Orleans handles the hard parts, like where each twin lives and how its memory is saved and moved between machines. So scaling is never a fragile cache trick. It is one safe, isolated twin for every thing that matters.
-
05 The MCP Boundary
ManagedCode.MCPGateway: remote MCP that scales.
The MCP spec describes a protocol. It does not describe multi-tenant logins, audit trails, cost caps, or rate limits, which is exactly what a real deployment needs. ManagedCode.MCPGateway is the edge layer Managed Code wrote so Prostir does not have to. It handles secure transport, per-customer access, per-tool limits, and clean error replies, all sitting in front of the Orleans runtime it routes calls into. One clean, guarded URL faces the world.
-
06 The Knowledge Layer
ManagedCode.MarkdownLd.Kb: knowledge, not prompt paste.
Uploaded files do not belong inside the prompt. ManagedCode.MarkdownLd.Kb takes a source, whether a Markdown file, a Word doc, a PDF, or structured data, and turns it into clean, typed knowledge plus a graph the agent can search. ManagedCode.Storage keeps it on Azure, and every tool's input is checked against a schema before it runs. The creator sees a library. The runtime sees a graph. The customer gets an answer with a citation, not a hallucination.
-
07 The AI Brain
One interface for every AI model.
Every model speaks a slightly different language. Microsoft built one .NET interface that hides those differences, so an agent can call OpenAI, Anthropic, or Azure with the same code. The Microsoft Agent Framework sits on top and runs the agent loops: it plans, calls tools, and remembers. Prostir ships both, wired to every major provider. The point is simple. You pick the model that fits the job, and you can switch it next week without touching anything else. The brain changes; the body stays.
-
08 The Builder Loop
Claude Code and Codex: the agents that shipped this.
We did not type Prostir line by line. The rules are plain. AGENTS.md is the long-term memory. Integration tests are the source of truth. Work ships in small vertical slices. Nothing merges until the tests are green. Claude Code writes and OpenAI Codex reviews, two agents checking each other until they agree. The agents are commercial. The product you are reading about is real. This is the loop that built it.
Claude Code OpenAI Codex -
09 The Product Edge
Blazor, Pay, Stateless, Jint: the creator-facing surface.
The creator never sees the gateway. They see a Blazor workspace. The operator never sees the grain map. They see a Blazor Server console. Stateless gives a conversation rails. The agent is always in some state, and the state decides what can happen next. Put it in a "gather the details" state and it will not jump to "give the answer" until the details are in, the same way you would not send a quote before you have heard what the customer needs. Jint runs small JavaScript snippets in a sandbox when a tool needs an exact number. payment-provider integration turns paid access into real permissions, with webhooks, checkout, and usage limits. This plain product layer is what makes the AI usable, and sellable.
-
10 The Static Story
Astro landing for crawlers, structured data for AI.
The page you are reading is a static Astro build. It is indexed for a perfect PageSpeed score and crawled by the same answer engines that fetch llms.txt. Every public route ships structured data, language tags, a sitemap, and an LLM discovery file, because the gap between a great backend and a backend people can find is metadata. Static where it should be, dynamic where it must be. The story ends where it was meant to be read, by people and machines alike.
The Result
One hosted, observable, sellable MCP endpoint per agent.
Ten enterprise layers collapse into a single URL. A creator pastes it into ChatGPT, Claude, Cursor, or any MCP client. Login, billing, knowledge, tools, state, memory, audit, and limits all come with it, running on today's distributed .NET: ASP.NET Core, Aspire, Orleans, the MCP gateway, and Microsoft.Extensions.AI. Built by AI. Run on .NET. Sold by you.
Why .NET
Same MCP server. Three different bills.
Independent benchmarks, no marketing math. What each language really costs in energy, speed, and built-in features for the same job.
| Capability | Node.js / Express | Python / FastAPI | Prostir (.NET 10) |
|---|---|---|---|
| Energy per task (lower is greener) | 1.4× .NET | 24× .NET | 1× (baseline) |
| TechEmpower composite rank | Mid pack | Bottom third | Top tier |
| Distributed actor framework | DIY / Akka.js | DIY / Ray | Orleans 10 virtual actors |
| Built-in DI, options, telemetry | Add libraries | Add libraries | Microsoft.Extensions.* |
| AI abstraction layer | LangChain.js | LangChain / LlamaIndex | Microsoft.Extensions.AI + Agent Framework |
| Ahead-of-time compilation | No | No | Native AOT |
| Strong typing without bolt-on | TypeScript transpile | Pydantic / mypy | C# 14, source-generated |
| Hot reload across full stack | Nodemon | Uvicorn reload | dotnet watch + Aspire |
Energy figures from the Pereira study, University of Minho (SLE'17 / SCP'21). Speed from TechEmpower Round 22.
Why Azure
Same MCP backend. Built for the cloud it runs on.
Not a price sheet, a fit sheet. These are the things a paid, multi-tenant MCP backend leans on, and where each one lands better on Azure. AWS is excellent. This is simply where the product fits.
| What matters | On AWS | Prostir on Azure |
|---|---|---|
| Compliance breadth | broad portfolio | GDPR · HIPAA · SOC · ISO · FedRAMP |
| Uptime SLA | per-service | up to 99.99% |
| Data residency | region pick | EU or US, your choice |
| Global distribution | CloudFront add-on | global backbone built in |
| First-party AI proximity | Bedrock + Anthropic | Azure OpenAI + Anthropic |
| Identity for end users | Cognito | Microsoft Entra External ID |
| Open-source runtime alignment | bring-your-own | .NET, Orleans, Aspire, all open source |
| Static site hosting + custom domain | S3 + CloudFront | Azure Static Web Apps (this site) |
Azure service capabilities as of 2026. AWS has equivalents for most rows. The table shows where Prostir's workload fits best, not who is cheapest.
Open source
The open source we ship, and the open source we use.
Prostir is built by Managed Code on top of Microsoft and community open source. Every package below is a real one from our project files, not a marketing wishlist.
Built by Managed Code
Managed Code is not just the footer credit. The MCP gateway, knowledge pipeline, storage, and Orleans integrations under your published agent are Managed Code opensource we maintain and ship.
- Managed Code The team behind Prostir. We open-source the backend primitives we use ourselves.
- ManagedCode on GitHub MCPGateway, MarkdownLd.Kb, Storage, Communication, Orleans extensions, and more.
- ManagedCode.MCPGateway Remote-MCP gateway with OAuth, multi-tenancy, audit, and per-tool quotas.
- ManagedCode.MarkdownLd.Kb Markdown-LD / JSON-LD knowledge pipeline with graph search.
- ManagedCode.Storage.Azure Storage abstraction for files, memory, and runtime artifacts on Azure Blob.
- ManagedCode.Communication Result, Command, and CollectionResult contracts across API and Orleans boundaries.
The .NET foundation
Everything Microsoft has been GA-ing since .NET 6 came together in .NET 10 and Aspire. That is the boring, dependable plumbing under every page on Prostir.
- .NET 10 Compiled runtime, Native AOT, source generators.
- ASP.NET Core 10 HTTP, auth, OpenAPI, SignalR, JsonPatch, hosted services.
- Aspire AppHost orchestration, service defaults, deployment resources.
- Microsoft Orleans 10 Virtual-actor runtime for distributed .NET: grains, persistence, placement, stateless workers, dashboard telemetry.
- EF Core 10 (Cosmos) Typed persistence and query model over Azure Cosmos DB.
- MudBlazor Material design components for the creator workspace.
AI, MCP & the libraries on top
The .NET-native AI stack Microsoft has converged on since 2024: one interface, every model, one Agent Framework that replaces Semantic Kernel and AutoGen. Plus the small, sharp libraries the runtime leans on: Jint for sandboxed scripts, Stateless for state machines, payment-provider integration for billing.
- Microsoft.Extensions.AI One interface for chat, embeddings, tool calls, and telemetry.
- Microsoft Agent Framework The official successor to Semantic Kernel and AutoGen.
- Model Context Protocol C# SDK The official C# SDK for MCP servers and clients.
- Jint A JavaScript engine inside .NET. It runs the tool scripts a creator writes.
- Stateless State machines that decide what the agent can do next.
- payment-provider integration The payment-provider client for paid access, checkout, and webhooks.
How this site is built and shipped
Prostir is built with AI and shipped as a static site. Claude Code and OpenAI Codex write and review, AGENTS.md keeps the delivery rules visible, and Astro builds the very page you are reading. You can run the same loop on your own product.
Technische FAQ
Vragen die teams stellen voordat ze op deze stack bouwen.
Deze antwoorden koppelen de stack aan echte productiekeuzes: Orleans, Aspire, C#, MCP, betalingen, toegang, kennis en zichtbaarheid voor operators.
Welk echt werk doet Orleans in Prostir? Orleans beheert langlevende runtime-identiteiten: agents, sessies, klanten, access grants, kanaalgesprekken, wallet holds en workflow runs. Elk onderdeel heeft een stabiel id, state en gedrag, in plaats van state te verstoppen in een singleton, cache of achtergrondproces. Lees
Wanneer is Orleans beter dan een queue plus CRUD API? Als je veel kleine, grotendeels onafhankelijke entiteiten hebt die request-response, start-monitor-complete-flows of state per identiteit nodig hebben. Microsoft noemt user profiles, purchase orders, sessions, stocks en social pub/sub; Prostir past hetzelfde patroon toe op agents, klantsessies en workflow runs. Lees
Wat is een grain in producttaal? Een grain is een virtual actor: een logisch object met identiteit, gedrag en optioneel persistent state. In Prostir kan dat een gepubliceerde agent, een klantgesprek, een access grant of een workflow run zijn. Lees
Hoe helpt Orleans met tenant-isolatie? State wordt gesleuteld op owner, agent, customer of run identity, waardoor werk in geïsoleerde grains terechtkomt en niet in gedeeld procesgeheugen. Een falende sessie wordt geen globale mutable state voor andere tenants. Lees
Wat zijn de grootste Orleans-risico's? De risico's zijn te praatgrage grains, één bottleneck-coördinator, blokkerende synchrone calls, te grote messages en verborgen shared state. Prostir houdt dat zichtbaar met verticaal ownership, async grain calls, stateless workers voor fan-out en integratietests via het echte Gateway/API/Orleans-pad. Lees
Wat voegt Aspire toe boven Docker Compose? Aspire geeft de .NET-oplossing één AppHost die projecten, dependencies, service discovery, configuratie, health, telemetry en cloud resources kent. Het is niet alleen processen starten; het is de resource graph voor lokaal werk, CI en Azure. Lees
Hoe gebruikt Prostir Aspire in tests? De AppHost start Cosmos DB, Azure Storage, Orleans, API, Gateway, Landing, WebApp en SuperAdmin voor echte integratie- en browsertests. MCP, billing, auth, storage en grain behavior lopen daardoor door dezelfde wiring als productie. Lees
Waarom is de runtime gebouwd in C# en .NET? De runtime heeft sterke contracten, async IO, dependency injection, options, telemetry, HTTP hosting, background workers, source generation en voorspelbare deployment nodig. .NET levert dat als first-party infrastructure, niet als losse pakketten. Lees
Vergrendelt .NET Prostir op één AI-provider? Nee. Microsoft.Extensions.AI en `IChatClient` geven een stabiele chat/tool-abstraction, terwijl het concrete model Azure OpenAI, OpenAI-compatible, Anthropic-compatible of een andere provider achter dezelfde runtime boundary kan zijn. Lees
Wat maakt MCP moeilijk in productie? Het protocol is alleen de ingang. Een betaalde remote MCP endpoint heeft ook OAuth, access grants, tenant checks, tool schemas, rate limits, quotas, billing, audit trails, betrouwbare errors en een hot path nodig die niet bij elke request de hele productdatabase leest. Lees
Waar past ManagedCode.MCPGateway? ManagedCode.MCPGateway is de protocol edge voor de Orleans runtime. Het publiceert de remote MCP endpoint, routeert tool calls, handhaaft zichtbare tool boundaries en houdt protocol concerns buiten de product-state API. Lees
Hoe wordt betaalde toegang een runtime permission? Checkout en webhooks van providers van de verkoper maken access grants aan of trekken ze in. Gateway controleert die grants vóór beschermde MCP calls, zodat payment state een runtime permission wordt en geen spreadsheet. Lees
Hoe voorkomt de knowledge layer prompt stuffing? Bestanden worden Markdown-LD / JSON-LD knowledge artifacts en doorzoekbare graph data. De runtime zoekt in de graph en geeft geciteerde context terug, in plaats van hele documenten in de prompt te plakken. Lees
Welke echte use cases passen bij deze stack? Goede matches zijn paid knowledge agents, support copilots met customer memory, process agents met state machines, channel agents voor Telegram of web widgets, verkoopbare skill passports en workflows die progress, retries en audit nodig hebben. Lees
Wanneer is deze stack te zwaar? Als je alleen een statische site, een eenmalige prompt demo of een privéchatbot zonder auth, tools, billing, state of customer memory nodig hebt, kies iets eenvoudigers. Prostir is bedoeld voor het moment waarop de agent een hosted product wordt waar anderen op rekenen. Lees
Tech
Map the technology to a real case.
The case studies show where each runtime layer matters: knowledge, tools, state, memory, billing, access, quotas, and operator visibility.