Build intelligent apps that adapt, and evolve effortlessly with people and AI.
The data model, the intent and the rules live in versioned files. The runtime plans, checks, runs and retries against them, and notices when something changes. A person, a coding agent or your own application can change a definition; every change is checked, versioned and reversible before it runs.
Mark a method with [AIIntent] and run it with ExecuteIntentAsync<T>, or call TransformAsync<T> on any value. The answer is your own type, checked against your rules before your code sees it.
IntentSharp is on NuGet: dotnet add package IntentSharp
No intent file needed. .NET 8, 9 and 10, with OpenAI, Anthropic or any IChatClient.
var email = "Hi, this is Dana from Northwind. We'd like 40 units of SKU A-1192 delivered by 2026-11-15.";var options = new AIRequestOptions() .Require<PurchaseRequest>(r => r.Quantity > 0, "Quantity must be a positive number.");var order = await client.TransformAsync<PurchaseRequest>(email, "Extract the purchase request from this email.", options);[Validator] attempt 1: Quantity must be a positive number.Success: true, after 2 attemptsValue: PurchaseRequest { Contact = Dana (Northwind), Sku = A-1192, Quantity = 40, DeliverBy = 2026-11-15 }Compiled and run with every build of this site. The model's answers are scripted.
The parse, check and retry loop, built in.
No confidence score. The result says what was checked. A pass means the checks passed, not that the answer is right.
The drawing: the path of one checked call
Each box links to its stage on the Overview.
- Your own objects back. Filter, sort and group your own objects. On success the original objects come back, selected or ordered by the model: a filter's matches once each, and every element exactly once for sort and group.
- Checks run in code. No check calls a model, except the optional judge. What does not call the model
- Wording and rules in a file. The folder is watched: save the file, and the next call uses it, with no release. A bad save keeps the last good version while the app runs. Intent files
- Tools for Microsoft Agent Framework.
AsAIFunctions()turns every enabled catalog intent into a standardAIFunctiontool, and each answer is checked before the agent sees it.
Or start from the problem you have: nine problems IntentSharp solves, each with an example compiled and run on scripted answers.
One set of files, changed by people and by AI
The intent, the data model, the rules and the examples live in plain YAML or JSON files, next to the code.
People
A person edits them like any other file and reviews the change like code.
Coding agents
A coding agent edits the same files, and reads the goal, the data model, the rules and the budget in one place instead of hunting through the call sites.
The running application
The running application can change them too: it proposes an edit, IntentSharp checks it, and the next call uses it, with no rebuild and no release.
A change that fails its checks is refused, and the version before it keeps running. Every change is a version you can read, compare and go back to.
Adapt and recover
When something changes, IntentSharp notices, checks, retries, falls back or recompiles, inside limits you set, and keeps the last good version when an edit is bad.
Your application learns from its reviewers: an accepted or rejected outcome becomes feedback the next call receives, through definitions and records you control. The model itself does not change, and nothing is retrained.
Change detectionOperate connected systems
An intent can read your data, plan a command against a database or an API, have it inspected and checked, and run it. What a plan may touch is a rule file, and an unset allow list refuses everything.
TargetsBuild with less of your own machinery
The parse, check, retry and fallback loop, the loader with hot reload, versions and revert, the edit seam and scripted providers for your tests ship in the library. You write the intent, the data model and the rules.
Our estimate for a typical business application: 20 to 40% less application code, the parsing, checking, retry, fallback and reload code you no longer write.
How it worksReadable by other programs
Definitions are YAML or JSON with a description written for people. A program can read the catalog's snapshot, an agent can call intents as tools with their data models, every edit reports what it changed, and the docs ship as llms.txt.
For agents and other programsWhy not just call the model?
For one typed call, GetResponseAsync<T> is enough. IntentSharp is the checking, retry, limit, fallback and reporting code you would write around every call after that.
The GetResponseAsync<T> column follows Microsoft's .NET structured-output quickstart (learn.microsoft.com/
| What you need | IntentSharp | GetResponseAsync<T> |
|---|---|---|
| Typed result | Built in | Built in |
| Missing member reported, not defaulted | Built in | You write it |
| Your rules checked | Built in | You write it |
| Retry with the findings | Built in | You write it |
| Limits on attempts, model calls and time | Built in | You write it |
| Every attempt kept, with raw output and tokens | Built in | You write it |
| Wording, data model and rules in a file that reloads | Built in | You write it |
And when something changes
| When this changes | IntentSharp | GetResponseAsync<T> |
|---|---|---|
| A rule changes | Save the file, the next call uses it | You change code and release |
| A schema changes | The runtime senses the target again and plans again, once | You write it |
| The provider changes | The provider file; a move of the key is flagged | You write it |
| A reviewer's stance changes | A new version of the intent, revert if it was wrong | You write it |
| A mapping's input drifts | Reported; a value it can no longer parse is recompiled, under an hourly cap | You write it |
From $349 per developer per year.
- 30-day free evaluation
- Unlimited deployments
- Keep the versions released while you paid
- Made by
- C2Consultants LLC, North Carolina
- Support
- By email; the support policy gives the response target for each edition