FAQ

Is Affiant Semantic Kernel–only?

No. Affiant’s interception logic runs identically over three backends — Semantic Kernel (SK), Microsoft Agent Framework (MAF), and Microsoft.Extensions.AI (M.E.AI) — each a thin translation bridge (Affiant.SemanticKernel, Affiant.AgentFramework, Affiant.Extensions.AI) over one shared, backend-neutral pipeline defined once in Affiant.Core. None of the three bridges contains any provenance-tagging, inference, or review-gating logic of its own. See Interception Backends for how to choose between them.

The provenance model itself has never been backend-specific. Affidavit, ProvenanceTag, ProvenanceChain, ToolEnvelope, DocketEntry, and the framework’s interfaces all live in Affiant.Abstractions — they describe data (what was written and where it came from), not how a tool call happened to get invoked. See Packages for the full dependency picture.

What about Microsoft Agent Framework (MAF) and Microsoft.Extensions.AI (M.E.AI)?

Both are first-class backends as of 1.0.0-beta.1, not a roadmap item. SK was the original backend; Affiant.AgentFramework joined the package set 2026-07-05, and Affiant.Extensions.AI joined 2026-08-20. See Using Affiant with Microsoft Agent Framework and Interception Backends for the host-facing guides.

Microsoft has stated it will “continue to support Semantic Kernel v1.x for the foreseeable future,” with a floor of at least one year past MAF’s general availability — not a dated end-of-life; see the SK-to-MAF migration guide for Microsoft’s current framing of the two side by side. MAF reached 1.0 GA on 2026-04-03, which puts that guaranteed floor at roughly 2027-04-03, with support continuing beyond it while SK usage remains substantial. Nothing in Microsoft’s primary documentation sets a hard SK end-of-support date. Picking MAF or M.E.AI over SK for a new host is forward-looking, not required — nothing about Affiant’s own tagging, inference, or review-gate behavior changes based on which you pick.

All three backends draw the same hosted-tool line: MAF’s own function-invocation middleware (FunctionInvocationContext, exposing an arguments view and a terminate flag) is documented as firing only for tools the client invokes locally — the same “client invokes tools locally” language Microsoft uses for Semantic Kernel’s model — and M.E.AI’s FunctionInvokingChatClient seam does too. Hosted tools (hosted MCP, code interpreter, web search, and similar provider-executed tools) bypass all three exactly the same way, and carry their own separate, server-side approval mechanism instead. Read the honest boundary for the full shape of that limit — each backend’s bridge reproduces it structurally, refusing at wire-up by default rather than staying silent about an uncovered hosted tool.

Should I use PostgreSQL or SQLite?

Both are first-class backends, picked per environment rather than one being the “real” option and the other a toy. Affiant.EntityFramework ships PostgresDocketStore and SqliteDocketStore alongside the matching PostgresChatSessionStore and SqliteChatSessionStore for session persistence; Affiant.Docket ships InMemoryDocketStore and the expiry sweep, and is required on every host regardless of which of the other two you add. See Docket & Evidence Cards for exactly which package registers what, and why the split exists.

Use SQLite for development and testing — zero external services to stand up, fast to reset between test runs, and the same schema as production so behavior transfers. Use PostgreSQL for production — the Docket’s payloads (an Affidavit’s fields, its provenance chains) are stored as jsonb, and Postgres gives you the durability and concurrent-write guarantees a review queue under real traffic needs. InMemoryDocketStore exists for unit tests that don’t need persistence at all and want to avoid touching disk. Migrations run through AffiantMigrator against whichever provider you’ve configured, so switching from SQLite in development to PostgreSQL in production doesn’t require a separate migration path.

Is Affiant net10.0 only?

Yes. All ten packages target net10.0 exclusively — there’s no net8.0 or netstandard2.0 multi-targeting today. If that’s a blocker for your host application, raise it on the GitHub repository.

What license is Affiant under?

Apache-2.0. It’s a deliberate choice for a framework that sits in the write path to a system of record: Apache-2.0 carries an explicit patent grant, which matters to the enterprise legal teams who scrutinize anything touching their production database, and it deters patent-based threats against adopters. See the LICENSE and NOTICE files in the repository for the full text.

Is Affiant production-ready?

Affiant is in beta. The public API — Affidavit, ProvenanceTag, ToolEnvelope, the DI extension methods, the package boundaries themselves — has been exercised end-to-end by two independent first-party host applications — both public: Meridian and HR Portal — but it hasn’t reached 1.0 general availability yet, and will keep changing before it does.

Adopt on this basis: trust the invariant, expect the API to evolve. The invariant — Rule 7, every Affidavit field carries provenance, no exceptions — is stable, and Affiant.Testing.ComplianceHarness exists specifically to enforce it as a CI gate in your own project, not just in Affiant’s. Type shapes, DI signatures, and package boundaries may still change between beta and 1.0 GA. Pin your version and read the changelog before upgrading.

Does Affiant slow down the agent loop?

For read tools, no added LLM cost: context extraction runs in deterministic Semantic Kernel filters (ContextExtractor subclasses), not as an extra model call — that’s Rule 4, filters over prompts for determinism.

For write tools decorated with [AffiantWriteTool], there is one real cost: InferenceTriggerFilter runs a structured-output completion (through IInferenceCompletionPort) before the tool executes, to fill in fields the Context Fabric doesn’t already hold deterministically. That’s one extra model round-trip on the write path — but it’s bounded and fails safe. It runs at most once per conversation turn per tool (idempotent on (ConversationId, FunctionName, TurnNumber)), and if it errors or times out, TaskInferenceRunner catches everything except a genuine cancellation, logs a warning, and lets the tool call proceed anyway — degraded confidence and a warning on the resulting Affidavit, never a broken turn. That’s Rule 5, graceful degradation, applied to the inference step specifically.

Can I use Affiant without SignalR?

Yes. Affiant.Transport.SignalR is a reference implementation of IStreamingTransport, not a requirement — the interface itself lives in Affiant.Abstractions, and everything above the transport layer (the Review Gate, the Docket, the policy graph) depends only on that interface, never on SignalR concretely.

To swap it out, implement IStreamingTransport yourself — SendAsync, BroadcastToGroupAsync, ReceiveAsync, AwaitEventAsync<T>, and TryDeliverResponse — and register it in place of calling AddAffiantSignalR<THub>(...). See Transport & Wire Contract for the full interface and what each method is responsible for.

Is there a roadmap?

Yes. Affiant’s public roadmap lists what’s being worked on now, next, and later — by status, never by date — at /roadmap/.