AsiBackbone Learning

Practical .NET architecture for accountable systems

Learn governed execution, secure application design, policy-driven systems, and safe AI integration through focused tutorials, hands-on labs, and runnable examples.

Learning makes the reasoning visible: why an operation was permitted, under which policy, with what evidence, and when a simpler design is enough. Use it before you adopt any implementation, or when a .NET system you design or review needs explicit decisions and audit evidence.

A proposed action should become a governed decision before it becomes real-world execution.

Start here

New to the project Follow the recommended introduction to the core concepts. I have a problem to solve Choose a short, goal-specific route through the material. I am evaluating by role Start from your developer, architecture, platform, AI, or security responsibility. The vocabulary is new Map Learning terms to established architecture concepts. I already use ASP.NET Core authorization See when framework-native authorization is enough—and when the problem is broader.

Is Learning a fit?

Use Learning when

  • you need to explain why an operation was permitted, under which policy, and with what evidence;
  • you are comparing governed execution with familiar .NET patterns before choosing an implementation; or
  • you want runnable examples and labs rather than a package to install.

Learning does not require installing an AsiBackbone package. Use it as independent .NET architecture education or connect it to the working repositories.

A simpler design may be enough when

The core model

The material uses a recurring separation of responsibilities:

  1. Intent
  2. Context
  3. Constraints
  4. Decision
  5. Decision receipt
  6. Acknowledgment when required
  7. Scoped authority
  8. Host-owned execution

Choose a learning path

Beginner to advanced

Architecture

Explore boundaries, responsibilities, tradeoffs, and structural patterns behind governed systems.

Explore Architecture
Beginner to advanced

Governance

Connect intent, policy context, explicit decisions, acknowledgment, scoped authority, and audit evidence.

Explore Governance
Beginner to intermediate

ASP.NET Core

Study secure defaults, middleware organization, operational structure, and modern .NET implementation patterns.

Explore ASP.NET Core
Beginner to advanced

Security

Examine trust boundaries, least authority, explicit control flow, defensive defaults, and accidental privilege.

Explore Security
Intermediate to advanced

AI Integration

Apply governed execution to AI-assisted systems, tool calls, agents, workflows, and host-controlled effects.

Explore AI Integration
Beginner to intermediate

Tutorials

Move from a familiar implementation through failure modes, tradeoffs, and working references.

Browse Tutorials
Beginner to intermediate

Executable Samples

Run small .NET companion samples for the foundation, governance, security, and ASP.NET Core paths, each with focused tests that make architectural invariants observable.

Browse Executable Samples
Intermediate to advanced

Labs

Practice with exercises, incomplete implementations, architecture critiques, and policy scenarios.

Browse Labs
Advanced

Advanced Topics

Explore complex integration patterns, alternative approaches, and deeper architectural questions.

Explore Advanced Topics

How Learning works

Tutorials use a problem-first progression:

  1. Problem
  2. Common implementation
  3. Failure mode
  4. Architectural pattern
  5. Teaching example
  6. Tradeoffs
  7. Working example

The goal is to make the reasoning visible—not to prove that one framework or architecture is always correct. Study a pattern, reimplement it, compare alternatives, identify when a simpler design is better, and treat working repositories as specimens rather than unquestioned templates.

Recently added

Published Learning archive: 1.6.0 (release notes). This site follows main and may publish additional articles after the archived tag; its contents are not an immutable copy of 1.6.0. Use the tag for reproducible citations.

The 2026-11-14 implementation-currentness review retains the deliberately reviewed teaching snapshots AsiBackbone v7.0.0 and NCAT v2.11.2, after examining published releases AsiBackbone v7.5.4 and NCAT v2.11.10. These are not recommendations to install older packages in new production applications. For current implementation releases and migration guidance, use the AsiBackbone releases and NCAT releases. The compatibility/API boundary documents the selected teaching contracts. Recent publications include:

New publications are announced in the RSS feed.

Scope, terminology, and important limitations

Canonical patterns document what the working repositories currently do; alternative patterns create room for comparison, criticism, and improvement. Canonical does not mean universal.

AsiBackbone Learning is an educational architecture resource—not a compliance certification, legal standard, security guarantee, AI model, AGI or ASI implementation, robotics controller, replacement for application-specific security review, or requirement to use the AsiBackbone package. Examples are teaching artifacts; production systems remain responsible for their own security, infrastructure, persistence, regulatory requirements, safety controls, and execution.

AsiBackbone is the product name; no acronym expansion is required to follow the material. AsiBackbone Learning is not affiliated with the Artificial Superintelligence Alliance.

Learn the patterns

AsiBackbone Learning Current site

Practical .NET architecture tutorials, labs, runnable samples, and reference patterns for governed execution, secure applications, AI integration, and policy-driven systems, including comparisons that show when these patterns are unnecessary.

Add governed decisions

AsiBackbone

A .NET governance and policy-control framework for auditable decision flows: policy evaluation, auditable decision records, acknowledgment workflows, capability-based authorization, host-owned execution boundaries, and ASP.NET Core integration.

Follow the integration

AsiBackbone Reference Application

An NCAT-generated ASP.NET Core host that records the step-by-step integration of AsiBackbone, with host-specific API documentation and runnable governance examples added as the walkthrough progresses.

Treat the working repositories as specimens to study, question, and compare rather than unquestioned templates.

Design philosophy

We favor architectures where consequential operations are explicit, constrained, reviewable, and auditable.

We also document when these patterns are unnecessary: see When ASP.NET Core Authorization Is Enough and When a Simple Application Service Is Enough.

The projects focus on practical .NET engineering. They do not claim regulatory certification or automatic compliance.

Read it. Run it. Question it. Improve it.