nascacht encodes deep domain expertise into composable .NET infrastructure — and gives your AI agents the semantic layer they need to operate reliably on insurance, healthcare, and lending data.
AI tools have made code replication nearly free. nascacht's value is what lives inside the infrastructure — and what the infrastructure makes possible.
Anyone can replicate a rules engine in an afternoon. What takes years is encoding the right domain expertise into it — pre-built eligibility rule sets, compliant document templates, pre-mapped schemas for Guidewire, Epic, and Encompass. That content compounds. It cannot be generated.
Enterprise AI agents fail in LOB contexts because they can't reliably reach business data or understand domain schemas. nc.Solution is the federation and semantic translation layer that solves this — multi-source, property-mapped, instance-graph-aware. nascacht is the infrastructure between your data and your AI.
Insurance, healthcare, and lending operate under regulatory frameworks that require more than working code. nascacht is built for SOC 2, HIPAA, and state-specific compliance — with audit trails, access control, and certified rule sets that pass CISO review. "Built with an AI tool last week" doesn't.
Every adapter — nc.Graph.EF, nc.Audit.EF, nc.Metadata.Redis, nc.Solution.OpenApi — is a solved integration problem your team doesn't have to rebuild. The ecosystem grows with every new connector. Once your schema, rules, and audit history live in nascacht, migration is a project, not an afternoon.
A virtual schema layer that federates your physical data sources into a single, AI-ready business model. The semantic bridge between your data and your agents.
// BA always uses solution-space names schema.TranslateToSource("Loan", "LoanNumber"); // → "loan_number" (physical SQL column) schema.TranslateToSource("Valuation", "EstimatedValue"); // → "zestimate" (Zillow API field)
Declare SQL databases, document stores, and OpenAPI endpoints as named sources. nc.Solution stitches them into a single business model without writing integration code.
Business analysts work with LoanNumber and EstimatedValue. nc.Solution translates to loan_number and zestimate before querying — and back again on the way out.
Navigate ancestors, descendants, and siblings of any entity across all sources. An AI agent asking "what's the full context of this loan?" gets a consistent, federated answer in one call.
No network calls, no reflection, no runtime scanning. The schema is built once at startup from configuration and registered as a singleton. Zero overhead in the hot path.
The AI angle. LLMs hallucinate in enterprise contexts when they can't ground their reasoning in current entity state. nc.Solution gives AI agents a reliable, schema-aware window into your business data — with the relationship graph intact.
Each package addresses one cross-cutting concern. Independent by design — take what you need, leave what you don't.
Composable rules engine with store-backed rule sets. Evaluates named rule sets against a JSON context. Built-in operators: equality, comparison, IN, wildcards, null checks.
Template string interpolation — resolver chain, JSON path, pipe formatting. Renders {ClaimAmount|decimal:C2} against any JsonDocument context.
Object graph traversal — fetch entity trees from any backing store via a concise selection DSL. Fans out concurrently. Partial success is first-class.
Operation dispatch with typed handlers and a composable middleware pipeline. Decouples callers from implementations via a MethodSignature DSL.
Append-only audit log keyed by entity, actor, and correlation ID. Captures before/after snapshots. Wave 3 adapters cover EF, CDC, and trigger tables.
Extranet access control — AWS-policy-style wildcard matching, specificity resolution, and trigger-maintained bulk entity filtering for performant SQL queries.
Attach arbitrary key-value metadata to any entity without schema changes. Transparent flat JSON at web boundaries via [JsonExtensionData].
Template storage, semantic versioning, and behavioral contracts. Governs status lifecycle and repeatability rules. Flat JSON seam compatible with nc.Rules and nc.Interpolation.
Single AddNascacht() entry point. Config-section-driven selective registration — only packages with a matching appsettings.json section are wired.
Adapter packages (nc.Graph.EF,
nc.Audit.EF,
nc.Metadata.Redis,
nc.Solution.OpenApi, …)
ship separately so core packages stay free of infrastructure dependencies.
nascacht ships with the patterns, rule sets, and schema mappings that matter in regulated, relationship-heavy industries. The domain knowledge is baked in.
Wire once. Every package follows the same three-layer registration pattern — zero config, config-driven, or delegate override.
// appsettings.json controls which packages are wired // section present → package registered; section absent → skipped services.AddNascacht("LoanOrigination", configuration);
{
"Nascacht": {
"SolutionName": "LoanOrigination",
"Interpolation": { "MaxDepth": 50 },
"Security": { "DefaultEffect": "Deny" },
"Dispatch": {}
}
}
services.AddNascachtSolution("LoanOrigination") .AddSource(new SourceDescriptor("loans_db", SourceKind.Sql)) .AddSource(new SourceDescriptor("zillow", SourceKind.OpenApi)) .AddModel(new ModelDefinition("Loan", "loans_db", PropertyMappings: [ new("LoanNumber", "loan_number"), new("Amount", "origination_amount"), ])) .AddRelationship(new RelationshipDefinition("Loan", "Payment", "Id", "LoanId")) .Services .AddNascachtGraph();
// Fetch the loan graph, evaluate eligibility, render a notification public class LoanNotificationService( IObjectGraph graph, IGraphSelectionParser parser, IRuleService rules, IInterpolationService interpolation) { public async Task<string> RenderApprovalAsync(string loanId, CancellationToken ct) { var selection = parser.Parse("Loan { Amount Status Insured { Name } }"); var context = await graph.GetContextAsync("Loan", loanId, selection, ct); var eligible = await rules.EvaluateAsync("ApprovalEligibility", context.ToDocument()); if (!eligible.Passed) return "Declined"; return await interpolation.InterpolateAsync( "Dear {Insured.Name}, your loan for {Amount|decimal:C2} is approved.", context.ToDocument(), ct); } }
We work with insurance carriers, healthcare organizations, and lenders to encode their domain expertise into nascacht — and connect their data to AI. The first reference engagement in your vertical shapes the product roadmap.
We wire nascacht into your stack and encode your domain rules and schemas.
Pre-built, domain-certified content libraries for your vertical.
nc.Solution as the grounding layer for your AI agents and copilots.