Agent, Skill, Flow, Team, and Store keep distinct identities and lifecycle boundaries.
Tech
Cloud-native AI platform, built on enterprise .NET from day one.
The prompt is the easy part. The harder work is identity, state, access, operations, and a stable public endpoint. Prostir builds those boundaries on .NET 10, Orleans, Aspire, and Microsoft Agent Framework.
The static Landing publishes explicit routes and metadata for every supported non-Russian locale.
From the compiled runtime and cloud resources to the public static discovery surface.
Each published Agent exposes its own slug-owned Streamable HTTP endpoint.
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.
01The Foundation
.NET 10 and C#: compiled and strongly typed.
Prostir uses .NET 10 and C# 14 for typed contracts, asynchronous I/O, dependency injection, options, telemetry, HTTP hosting, background services, and source generation. Those capabilities fit a product that spans APIs, durable runtime owners, protocol endpoints, and browser applications. Language choice alone does not guarantee cost, performance, energy use, or supply-chain safety; those outcomes still depend on the workload, dependencies, deployment, and operations.
02The Cloud
Azure: managed services with explicit deployment boundaries.
Azure Container Apps, Cosmos DB Serverless, Blob Storage, Monitor, managed identity, and RBAC provide the cloud primitives used by Prostir. Azure publishes service-specific compliance documents and availability terms, but those do not automatically certify Prostir or create one blanket Prostir SLA. Regions and resources are provisioned by the operating environment, not selected by a customer on this page.
03The Local Bridge
Aspire: one AppHost, integration-level wiring.
Prostir.AppHost composes Cosmos DB, Azure Storage, Orleans, the API, Gateway, WebApp, Landing, and SuperAdmin for local and automated integration flows. The test harness owns those dependencies and exercises real service boundaries where the suite requires them. That makes configuration drift easier to find, while production readiness still depends on deployment-specific validation, monitoring, and release checks.
04The Distributed Runtime
Orleans: durable owners for stateful work.
Microsoft Orleans gives Prostir identity-keyed virtual actors for Agents, sessions, access grants, workflow runs, and other long-lived runtime state. Each grain owns a bounded responsibility and coordinates its own state instead of relying on shared process memory. Orleans supplies activation, placement, persistence integrations, reminders, and messaging; Prostir still defines authorization, product boundaries, failure handling, and operational policy.
05The 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.
06The Knowledge Layer
ManagedCode.MarkdownLd.Kb: searchable source context.
ManagedCode.MarkdownLd.Kb turns supported sources into Markdown-LD or JSON-LD artifacts and graph data that the runtime can search. ManagedCode.Storage owns the file boundary, while JsonSchema.Net validates MCP tool inputs against their declared schemas. Retrieval can return source-linked context when the indexed material supports it; answer quality and citations still depend on source quality, indexing, runtime configuration, and the selected model.
07The AI Brain
One application boundary for configured models.
Microsoft.Extensions.AI provides the IChatClient abstraction used across Prostir, and Microsoft Agent Framework owns prompt and declarative Agent execution. Current runtime routes use Azure OpenAI, OpenAI-compatible providers, or creator-owned connections exposed through that boundary. Availability and switching depend on the configured provider, compatible model capabilities, credentials, and product policy.
08The Builder Loop
Agent-assisted delivery with visible engineering rules.
Prostir uses repository-owned AGENTS.md rules, vertical feature slices, code review, focused checks, integration tests, and release gates. Coding agents can assist with research, implementation, and review, but they do not replace product ownership, human judgment, or the verification required for each change.
Claude CodeOpenAI Codex09The Product Edge
Blazor, Stripe and Rozetka 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. Stripe and Rozetka Pay 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.
10The Static Story
Astro landing with explicit discovery metadata.
The page you are reading is generated as static Astro HTML. Canonical links, localized hreflang, structured data, the sitemap, IndexNow support, and llms.txt make the intended public routes machine-readable. Local checks cover HTML, crawlability, accessibility, and Lighthouse templates, while search engines remain responsible for crawling, indexing, and ranking.
The Result
One hosted, observable, sellable MCP endpoint per agent.
The layers meet at one slug-owned MCP URL for each published Agent. Supported clients can connect to that Streamable HTTP endpoint, while access, billing, knowledge, tools, state, memory, audit, and limits remain explicit capabilities enabled by the Agent's configuration and entitlements. The runtime is built on ASP.NET Core, Aspire, Orleans, ManagedCode.MCPGateway, and Microsoft.Extensions.AI.
Why .NET
Three viable stacks, one documented Prostir choice.
Node.js, Python, and .NET can all host MCP servers. This table describes the implementation choices Prostir actually uses; it is not a universal performance, cost, energy, or security ranking.
| Capability | Node.js / Express | Python / FastAPI | Prostir (.NET 10) |
|---|---|---|---|
| HTTP runtime | Node.js runtime | Python ASGI runtime | ASP.NET Core 10 |
| Identity-keyed distributed state | Choose a state framework | Choose a state framework | Orleans 10.2.2 virtual actors |
| Dependency injection, options, telemetry | Framework or library choice | Framework or library choice | Microsoft.Extensions.* |
| AI abstraction | Provider libraries or abstraction | Provider libraries or abstraction | Microsoft.Extensions.AI + Agent Framework 1.15 |
| MCP SDK | Official MCP TypeScript SDK | Official MCP Python SDK | Official MCP C# SDK 1.4.1 |
| Tool-schema validation | Library-selected validation | Library-selected validation | JsonSchema.Net 9.3 |
| Contract model | TypeScript contracts | Python typing tools | C# 14 + source generation |
| Local composition | Local process tooling | Local process tooling | dotnet watch + Aspire AppHost |
The Node.js and Python columns name common choices, not limitations. Prostir's column is verified against the current repository package and project files.
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 and control evidence | Service-specific controls and certifications | Azure service controls; Prostir deployment assessed separately |
| Availability terms | Per-service and per-region terms | No blanket Prostir SLA is claimed here |
| Regional placement | Region configured per workload | Operator-provisioned regional resources |
| Network and ingress | Optional global networking services | Configured Gateway and static-site routing |
| Model-provider routes | Bedrock and partner model routes | Azure OpenAI, OpenAI-compatible, and creator BYOK routes |
| Customer access | Cognito or custom identity | Prostir access and OAuth policy above the hosting layer |
| Application runtime | Runtime selected by the team | .NET, Orleans, Aspire, and Managed Code libraries |
| Static landing hosting | S3 + CloudFront or Amplify | Azure Static Web Apps for this landing |
Cloud providers document their own service capabilities. Prostir certification, SLA, deployment regions, and operating controls must be verified separately for the actual environment.
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 CodeThe team behind Prostir. We open-source the backend primitives we use ourselves.
- ManagedCode on GitHubMCPGateway, MarkdownLd.Kb, Storage, Communication, Orleans extensions, and more.
- ManagedCode.MCPGatewayRemote-MCP gateway with OAuth, multi-tenancy, audit, and per-tool quotas.
- ManagedCode.MarkdownLd.KbMarkdown-LD / JSON-LD knowledge pipeline with graph search.
- ManagedCode.Storage.AzureStorage abstraction for files, memory, and runtime artifacts on Azure Blob.
- ManagedCode.CommunicationResult, 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 10Compiled runtime, C# 14, and source generators.
- ASP.NET Core 10HTTP, auth, OpenAPI, SignalR, JsonPatch, hosted services.
- AspireAppHost orchestration, service defaults, deployment resources.
- Microsoft Orleans 10Virtual-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.
- MudBlazorMaterial design components for the creator workspace.
AI, MCP & the libraries on top
Prostir uses Microsoft.Extensions.AI as its chat-client boundary and Microsoft Agent Framework 1.15 for Agent execution. The runtime also uses the official MCP C# SDK 1.4.1, Jint for bounded JavaScript tools, Stateless for state machines, and Stripe and Rozetka Pay integrations for supported payment paths.
- Microsoft.Extensions.AIOne interface for chat, embeddings, tool calls, and telemetry.
- Microsoft Agent FrameworkMicrosoft Agent Framework 1.15 for prompt and declarative Agent execution.
- Model Context Protocol C# SDKThe official C# SDK for MCP servers and clients.
- JintA JavaScript engine inside .NET. It runs the tool scripts a creator writes.
- StatelessState machines that decide what the agent can do next.
- Stripe and Rozetka Pay integrationThe payment-provider client for paid access, checkout, and webhooks.
How this site is built and shipped
Prostir uses agent-assisted development alongside repository rules, code review, automated checks, and human ownership. AGENTS.md keeps the delivery contract visible, while Astro builds the static localized page you are reading.
- Agent-assisted developmentAGENTS.md and integration tests keep the agent-assisted build loop predictable.
- Repository delivery rulesAgent-assisted development is bounded by the same repository and review rules as other changes.
- AstroRepository delivery rules describe ownership, verification, and release boundaries.
Tech FAQ
Questions teams ask before they build on this stack.
These answers map the stack to real production decisions: Orleans, Aspire, C#, MCP, billing, access, knowledge, and operator visibility.
What real work does Orleans do in Prostir?Orleans owns long-lived runtime identities: agents, sessions, customers, access grants, channel conversations, wallet holds, and workflow runs. Each one can keep state and behavior behind a stable id instead of hiding that state in a singleton, cache, or background process.Read
When is Orleans better than a queue plus CRUD API?Use Orleans when you have many small, mostly independent entities that need request-response work, start-monitor-complete flows, or per-identity state. User profiles, purchase orders, sessions, stocks, and social pub/sub are official fit examples; Prostir maps the same pattern to agents, customer sessions, and workflow runs.Read
What is a grain in product terms?A grain is a virtual actor: a logical object with an identity, behavior, and optional persistent state. In Prostir that might be one published agent, one customer conversation, one access grant, or one workflow run.Read
How does Orleans help with tenant isolation?State is keyed by owner, agent, customer, or run identity, so work naturally lands in isolated grains instead of shared process memory. A failing session or customer flow does not become global mutable state for every other tenant.Read
What are the main Orleans risks?The risky patterns are chatty grains, one bottleneck coordinator, blocking synchronous calls, oversized messages, and hidden shared state. Prostir keeps those risks visible with vertical ownership, async grain calls, stateless workers for fan-out, and integration tests through the real Gateway/API/Orleans path.Read
What does Aspire add that Docker Compose does not?Aspire gives the .NET solution one AppHost that knows the projects, dependencies, service discovery, configuration, health, telemetry, and cloud resource shape. It is not only process startup; it is the resource graph used by local dev, CI, and Azure deployment.Read
How does Prostir use Aspire in testing?The AppHost starts the resources required by integration and browser tests, including Cosmos DB, Azure Storage, Orleans, API, Gateway, Landing, WebApp, and SuperAdmin. This exercises the same service boundaries, while production still has deployment-specific configuration and release checks.Read
Why build the runtime in C# and .NET?The runtime needs strong contracts, async IO, dependency injection, options, telemetry, HTTP hosting, background workers, source generation, and predictable deployment. .NET gives those as first-party infrastructure instead of stitching them from unrelated packages.Read
Does .NET lock Prostir to one AI model provider?No. Microsoft.Extensions.AI and `IChatClient` give Prostir a stable chat/tool boundary. The concrete model comes from a configured Azure OpenAI, OpenAI-compatible, or creator-owned connection that meets the runtime contract.Read
What makes MCP hard in production?The protocol is only the entry point. A paid remote MCP endpoint also needs OAuth, access grants, tenant checks, tool schemas, rate limits, quotas, billing, audit trails, reliable errors, and a hot path that does not read the whole product database on every request.Read
Where does ManagedCode.MCPGateway fit?ManagedCode.MCPGateway is the protocol edge in front of the Orleans runtime. It exposes the remote MCP endpoint, routes tool calls, enforces visible tool boundaries, and keeps protocol concerns out of the product-state API.Read
How does paid access stay connected to runtime permissions?Checkout and webhooks from seller-owned providers create or revoke access grants. Gateway checks those grants before protected MCP calls, so payment state becomes a runtime permission instead of a spreadsheet or manual invite list.Read
How does the knowledge layer avoid prompt stuffing?Files become Markdown-LD / JSON-LD knowledge artifacts and searchable graph data. The runtime retrieves bounded, source-linked context when the index supports it instead of pasting whole documents into a prompt; answer quality still depends on the sources, indexing, configuration, and model.Read
What real use cases fit this stack?Good fits are paid knowledge agents, support copilots with customer memory, process agents with state machines, channel agents for Telegram or web widgets, tool-selling skill passports, and workflow products that need progress, retries, and audit.Read
When is this stack too much?If you only need a static website, a one-off prompt demo, or a private chatbot with no auth, tools, billing, state, or customer memory, use something simpler. Prostir exists for the moment the agent becomes a hosted product other people depend on.Read
Is Prostir an API product or an MCP product?For people using an Agent in Claude, ChatGPT, and other compatible AI clients, the delivery path is its remote MCP endpoint. Prostir also uses APIs and webhooks for browser management, payments, and approved system integrations. The platform is cloud-hosted on .NET and Azure; a specific CRM, database, or private-system connection depends on the plan and may need a custom scope.Read
Tech
Map the technology to a concrete product path.
The guides and examples show where runtime layers matter: knowledge, tools, state, memory, billing, access, quotas, and operator visibility. Verified customer cases remain a separate evidence category.