Turn your .NET app
into a platform.

Add document readers, scoring strategies and customer-specific rules in C#, Python or TypeScript. Reuse local MCP tools too. WeavePort manages the workers. Your application keeps control of data and permissions.

Run your first example Discover WeavePort

Open source · MIT licensed · Built for .NET 10

MCP tools, managed by your .NET host

Reuse the tool. Keep control of its lifecycle.

Bring trusted local MCP servers into the same host as your C#, Python and TypeScript plugins. Discover tools, call them from C#, and share worker budgets, deadlines and cleanup. One server can offer many capabilities. No AI model required.

Use MCP tools → · Run the C# example →

Local stdio · MCP 2025-11-25 and 2026-07-28 · tools/list and tools/call. Native plugins remain the default. Remote HTTP and interactive continuations are outside this release; local code must be trusted.

ONE CONTRACT. THREE LANGUAGES.

Write the function.
WeavePort connects it.

Start with a small echo plugin. Add your own logic, result streams and approved callbacks as your product grows.

Plugin

Python

from weaveport_sdk import PluginApplication

app = PluginApplication()

@app.function("echo")
async def echo(value, context):
    return value

app.run()

C#

using System.Text.Json;
using WeavePort.Sdk;

await new PluginApplication()
    .Function<JsonElement, JsonElement>("echo",
        (input, _, _) => ValueTask.FromResult(input))
    .RunAsync();

TypeScript

import { PluginApplication } from '@weaveport/sdk';

const app = new PluginApplication();
app.function('echo', async input => input);

await app.run();

YOUR .NET APPLICATION

The same call.
Whichever language you choose.

Functionecho

Input{ "message": "hello" }

Result{ "message": "hello" }

Illustrative contract. Your host selects the artifact and authorizes the binding before calling it.

Run the complete integration

Windows, Linux and macOS. Trusted plugins over standard input/output. Release validation: macOS arm64; Windows and Linux validation pending. The 0.3.1 API is evolving; native execution is not a hostile-code sandbox. See support details.

BUILD WHAT MAKES YOUR PRODUCT DIFFERENT

More room for ideas.
Less runtime plumbing.

A new reader. A different algorithm. A customer’s own rules. Give each one a defined place in your application.

Let the language fit the job.

Use Python for a strategy, TypeScript for a rule or C# for a reader. Your .NET application calls them through the same client interface.

Functions and streams →

Open the right doors.

Native plugins reach your services through explicit callback grants. The application supplies the tenant identity and checks access to each object.

How access works →

Give workers one home.

Share startup, deadlines, worker budgets and cleanup through one host. The coordinator template connects that budget to application operations.

Embed the runtime →

Keep your application's architecture.

Your contracts, database and workflows stay yours. WeavePort is a set of NuGet libraries embedded in your backend.

Where WeavePort fits →

IDEAS YOU CAN RUN

Start closer to your use case.

Three complete applications show the decisions around the plugin, from access to committed results.

STRATEGIESLet customers choose
how decisions are scored.

Compare C# and Python evaluators with scoped knowledge and replayable results.

Explore Decision Room DOCUMENT PROCESSINGAdd a reader.
Keep your workflow.

Swap document readers while the application controls source access and staged commits.

Explore Document Workshop BUSINESS RULESMake scheduling
rules replaceable.

Follow booking strategies, idempotent actions and recovery in one shared coordinator.

Explore Appointment Desk

SMALL ENOUGH TO TRY. OPEN ENOUGH TO INSPECT.

Take it for a run.

Start with Decision Room and see a plugin participate in a real application. Then adapt the host and contracts to your product.

The example runs on the qualified macOS arm64 path with .NET 10 and Python 3.11+. Initial package restore needs network access.

Start the walkthrough →

Terminal

git clone https://github.com/yesbert/WeavePort.git
cd WeavePort
./scripts/decision-room.sh --build

Expected: proposal B wins with a score of 11.

BEFORE YOU BUILD

A few useful answers.

Read the full FAQ →

Is this a good fit for my application?

WeavePort fits a .NET backend that needs owner-approved extension code: strategies, readers and domain rules. You define each contract, choose the artifacts and decide which application services they can call.

Can I run untrusted plugins?

The native execution path runs with your application’s OS-user rights. It is for trusted code. Running arbitrary untrusted uploads needs a stronger, separately qualified execution boundary.

What can I install today?

The four core NuGet packages are public at 0.3.1 under MIT. Python and TypeScript author SDKs are built from this repository. The API is evolving. Trusted stdio execution supports Windows, Linux and macOS; Windows and Linux release validation is pending. Remote production deployment is not qualified by this release.

Do I need to change my database or workflows?

Your application keeps its own domain contracts, durable state and recovery policy. WeavePort manages the execution layer; callbacks connect plugins to services you already own.

Turn your .NET app into a platform.