Python vs .NET Feature Parity Matrix
This repo ships two complete backends over the same domain: agents/python/ (Microsoft Agent Framework’s Python SDK) and agents/dotnet/ (the .NET/C# SDK). Development here is Python-first — new capabilities land in Python first, and the .NET backend follows on a prioritized backlog rather than in lockstep. This matrix replaces an earlier, less accurate “feature-parity” claim in the root README.md with an honest, per-concept breakdown of what’s actually implemented on each side today, verified directly against the code (not carried forward from an older description).
See also docs/agent-audit-matrix.md for the security-specific breakdown (injection defense, role enforcement, eval/red-team coverage) — this document covers the wider feature surface; the two overlap on guardrails and cross-link rather than duplicate.
Status legend
| Status | Meaning |
|---|---|
| Full | Implemented and wired into the live request path on both sides |
| Partial | Present but incomplete, or present in one form and not the equivalent form (noted inline) |
| Python-first — planned | Python has it; .NET doesn’t yet, and it’s on the backlog below |
| Not supported by MAF .NET | Blocked on the underlying .NET SDK, not a gap this repo can close alone |
Priority reflects the backlog order in issue #11’s linked gaps — P1 first.
Matrix
| # | Concept | Python | .NET | Status | Priority | Issue | |
|---|---|---|---|---|---|---|---|
| 1 | Middleware / context-provider pipeline attached to agents | shared/middleware.py’s build_specialist_middleware() wired into every specialist’s Agent(...) construction | Shared/Agents/SpecialistPipeline.cs composes AgentRunLogger, ToolAuditMiddleware, and PiiRedactor via AIAgentBuilder’s .Use(...) pipeline (agent-run + function-invocation seams, MAF .NET 1.18+); ContextEnricher is attached via a new EcommerceContextProvider : AIContextProvider on ChatClientAgentOptions.AIContextProviders. SpecialistAgentFactory.Create() applies both whenever a caller passes its IServiceProvider, which all 6 agent-construction call sites (5 specialists + orchestrator) now do | Full | — | #12 (closed) | |
| 2 | MCP server protocol | Two real MCP servers (MCPServer) (packages/mcp-product, packages/mcp-inventory) — streamable-HTTP transport, real JSON-RPC | ECommerceAgents.Mcp now uses the official ModelContextProtocol.AspNetCore SDK — real JSON-RPC over streamable HTTP (MapMcp("/mcp")), [McpServerToolType]/[McpServerTool] tools, verified live (initialize + tools/list + tools/call over the wire) and via an end-to-end McpClient test | Full | — | #13 (closed) | |
| 3 | Streaming chat to specialists (/message:stream) | shared/agent_host.py exposes both /message:send and /message:stream (SSE) on every specialist; orchestrator/agent.py’s call_specialist_agent consumes the specialist’s stream and forwards live event: delta frames while the tool call is in flight | AgentHost.cs now maps POST /message:stream on every specialist (RunAgentWithHistoryStreamingAsync); A2AClient.StreamAsync consumes it; OrchestratorTools.CallSpecialistAgent forwards each delta into a request-scoped Channel<string> (RequestContext.StreamScope, the .NET analog of Python’s current_stream_queue) that ChatRoutes.StreamAsync drains concurrently into event: delta frames on the outer SSE response — same live-preview behavior as Python’s tool mode. Scoped to the tool orchestration mode only; .NET has no other orchestration modes to extend this to (see rows 11-13) | Full | — | #14 (closed) | |
| 4 | Inbound prompt-injection detection | shared/guardrails/injection_middleware.py, attached via the shared middleware pipeline | Shared/Guardrails/Sanitize.cs (patterns ported verbatim) + SpecialistPipeline’s combined guardrail gate, built on the AIAgentBuilder.Use(runFunc, streamingFunc) seam so it can fully short-circuit before the chat client. Observe-only by default (flags via RequestContext.CurrentGuardrailFlags); GUARDRAILS_BLOCK_ON_INJECTION escalates to a hard refusal, same as Python | Full | — | #15 (closed) | |
| 5 | Stored-content sanitization (tool results re-entering the model) | shared/guardrails/output_middleware.py | Shared/Guardrails/OutputSanitizer.cs — reflection-based recursive walk of a tool’s returned record (the .NET twin of Python’s dict-key-based neutralize_value, since .NET tools return strongly-typed records, not dicts), gated by a new SanitizeToolsConfig.SanitizeTools allowlist (tool name → property names) covering the same three specialists Python’s table does, wired into the function-invocation seam alongside ToolAuditMiddleware | Full | — | #15 (closed) | |
| 6 | Output moderation (self-harm / hate / violence phrase screening) | shared/guardrails/moderation.py + moderation_middleware.py | Shared/Guardrails/Moderation.cs (patterns ported verbatim), checked on the final response text by the same combined guardrail gate as row 4. OUTPUT_MODERATION_MODE=enforce replaces a non-streaming response; a streamed response can only be flagged post-hoc (chunks already on the wire) — same documented trade-off as Python | Full | — | #15 (closed) | |
| 7 | Step recorder → live agentic timeline | shared/agent_observability.py’s StepRecorderMiddleware, attached to every agent, drained per-request into SSE event: step frames and the /runs UI | SpecialistPipeline’s RecordSteps stage (function-invocation seam, unconditional like Python’s) appends one ExecutionStep per tool call to a new RequestContext.CurrentSteps. A specialist returns its own steps over A2A (AgentResponse.Steps on /message:send; an event: steps bulk SSE frame on /message:stream); A2AClient merges them into the orchestrator’s own timeline, tagged with the specialist’s name. ChatRoutes now calls the previously-unused UsageRecorder.LogExecutionStepAsync() per step after persisting the turn, and StreamAsync emits one event: step SSE frame per step (same wire shape web/src/lib/api.ts’s AgentStep parser already expects) — so /runs and the live timeline now populate for the .NET backend too | Full | — | #16 (closed) | |
| 8 | Fan-out/fan-in + sequential HITL-gated workflow construction | workflows/pre_purchase.py and workflows/return_replace.py both use MAF’s WorkflowBuilder — real executor graphs; return_replace.py’s policy gate (before anything is created) uses ctx.request_info to pause and is answered with a ReturnDecision | Both PrePurchaseWorkflow.cs and ReturnAndReplaceWorkflow.cs now build real WorkflowBuilder graphs (Microsoft.Agents.AI.Workflows 1.18.0), executor ids matching Python’s 1:1. PrePurchaseWorkflow’s fan-in barrier collects the three upstream messages one at a time (MAF delivers them separately, not batched) via a MergeStates merge, since .NET executors can’t share one mutable state object across parallel branches the way the old Task.WhenAll version did. ReturnAndReplaceWorkflow’s HITL gate uses a RequestPort (MAF .NET has no ctx.request_info-equivalent ad-hoc pause from inside an arbitrary executor — pausing requires a dedicated port node), with a GateDecisionExecutor (policy-gate) routing to the port or straight to initiate-return by explicit targetId depending on what the approval policy engine (ApprovalPolicy, kind return_approval) says — auto does not pause; ReturnHitlThreshold is only the fallback when the engine cannot decide. The port answers a ReturnDecision record (decision, resolution, amount, note, decided_by, approval_id), the same shape as Python’s, and the return is created only after approval, so a rejection leaves no return row. The .NET resume route and POST /api/approvals/{id}/decide now carry the reviewer’s full ReturnDecision (edited resolution and amount) through the approvals port (D-5n, row 35). Python’s two-call execute()/resume-via-responses={...} contract maps to one long-lived StreamingRun cached across the pause (verified empirically before implementing: break out of the event stream on RequestInfoEvent without disposing the run, later call SendResponseAsync and open a fresh WatchStreamAsync() on the same run — resumes correctly), keyed by order id so one workflow instance can have multiple orders paused concurrently. The full WorkflowState survives the pause on both stacks (Python carries it in the approval request; .NET parks it in the workflow’s checkpointed scope). Both stacks now wire these to live routes: Python registers them in orchestrator/modes/, .NET in ModeRegistry (PrePurchaseMode, ReturnReplaceMode). .NET additionally checkpoints through MAF’s own ICheckpointStore and can resume a paused run from storage rather than from a live in-process object, so a pending approval survives an orchestrator restart | Full | — | #17 (closed) | |
| 9 | Human-in-the-loop as middleware | shared/hitl.py intercepts five destructive tools at the middleware layer, independent of each tool’s own body | HitlGate is now a real interception layer, wired into SpecialistPipeline’s function-invocation pipeline (the same seam ToolAuditMiddleware/OutputSanitizer use) — CancelOrder/ModifyOrder/PlaceBackorder no longer know or need to know they’re gated; a gated call is short-circuited before the tool method ever runs, matching Python’s “don’t call call_next()” exactly, with the same generic {status, message, request_id} result shape Python returns (rather than trying to preserve each tool’s typed result for the pending case). Also fixes a real bug found during the port: the old call-site wrapper failed open on a DB error — contradicting Python’s own fail-closed behavior — now fails closed | Full | — | #17 (closed) | |
| 10 | Shared tool library | shared/tools/ — 8 modules, 1,473 lines, imported by whichever specialists need them (cart_tools.py, return_tools.py, seller_tools.py, loyalty_tools.py, inventory_tools.py, user_tools.py, memory_tools.py, pricing_tools.py) | Shared/Tools/ now holds the cross-cutting modules — ProductLookupTools, UserProfileTools, StockLookupTools, PriceHistoryTools, LoyaltyTools, ReturnTools — registered by whichever specialists need them, the same shape as Python’s shared/tools/. Domain-specific logic stays in each specialist’s own Tools/ folder on both sides | Full | — | #18 | |
| 11 | Handoff orchestration | orchestrator/handoff.py’s HandoffBuilder mesh over RemoteSpecialistChatClient | Modes/HandoffMode.cs — a real AgentWorkflowBuilder.CreateHandoffBuilderWith mesh. It was previously a hand-rolled router over the A2A client, because MAF’s handoff orchestration takes AIAgent participants and a specialist lives behind an HTTP hop; RemoteSpecialistChatClient is the adapter that closes that gap — an IChatClient whose “model” is the far side of an A2A call, and the direct twin of Python’s shared/remote_agent.py. Both stacks now start from a tool-free triage agent: seeding the mesh with the tool-calling orchestrator meant it routed and answered instead of handing off (23,637 characters from orchestrator with no specialist speaking at all) | Full | — | #19 | |
| 12 | Group chat orchestration | workflows/group_chat.py — two agent panelists + a moderator | Modes/GroupChatMode.cs — same two panelists and moderator, same prompts, same sequential-transcript shape | Full | — | #19 | |
| 13 | Magentic orchestration | Not present. orchestrator/modes/ holds base, tool_router, handoff_mode, workflow_mode and group_chat_mode — there is no magentic_mode.py; an earlier version of this row cited one | Not present, but now available: Microsoft.Agents.AI.Workflows 1.28.0 exports MagenticWorkflowBuilder and its plan/ledger events (Magentic was Python-only through MAF v1.1; this surfaced when #84 moved the .NET packages to 1.28). tutorials/16-magentic-orchestration/dotnet/tests/MagenticTests.cs began as a tripwire asserting absence; it fired, and was inverted to pin that the types exist, that the Python names MagenticBuilder / StandardMagenticManager still do not, and — as a control against a failed assembly load — that the sibling orchestration builders are present. The chapter’s .NET side is still a status stub awaiting a port. An earlier revision of this row claimed .NET shipped MagenticWorkflowBuilder when it did not (1.1.0 / 1.18.0 lacked it); it does now | Neither stack — not a parity gap | — | #19 | |
| 14 | Eval harness | evals/harness.py’s ProductionRunner, real scorers, committed baselines, CI-gated smoke suite | src/ECommerceAgents.Evals — a console runner that drives the real ModeRegistry (so guardrails, sanitization and HITL gates run, as in Python’s ProductionRunner), with the same scorers’ shape, --baseline / --max-regression / --update-baseline, and .github/workflows/evals-dotnet.yml. Six agent datasets are ported (five byte-identical to Python’s; product_discovery has 5 cases to Python’s 6); the red_team dataset is not. Only one baseline is committed (baselines/orchestrator.json; Python commits six). Manual dispatch only — no PR gate, unlike Python’s smoke suite | Partial | P3 | #19 | |
| 15 | Long-term memory — write path | shared/tools/memory_tools.py — agent-callable save/update tools | Shared/Tools/MemoryTools.cs — StoreMemory and RecallMemories, registered on product-discovery and review-sentiment exactly as Python registers them, alongside the existing read paths (ContextEnricher, ProfileRoutes). Identity comes from RequestContext, so the model cannot write onto another user’s profile | Full | — | #19 | |
| 16 | Tutorial chapter test coverage (tutorials/*/dotnet/) | 32 chapters ship code, all with tests (non-integration suite green in CI) | 31 chapters ship code, all with tests. Not ported: ch20b — Microsoft.Agents.AI.DevUI is still prerelease-only (1.28.0-preview). Every .NET chapter and the production backend pin Microsoft.Agents.AI* 1.28.0, through tutorials/Directory.Packages.props and agents/dotnet/Directory.Packages.props respectively. Ch16’s .NET is a documented status stub: Magentic now ships in .NET (MagenticWorkflowBuilder) but the chapter has not been ported, and its tests pin the types’ existence. Ch21 is planned on both sides. | Parity | — | #20 | |
| 17 | Server-side grounding | shared/grounding/{ledger,extractor,verifier,middleware}.py — three tiers (per-request tool-result ledger, batched DB lookup, consistency check), GROUNDING_MODE off/observe/annotate/enforce | Shared/Grounding/{ClaimExtractor,GroundingVerifier}.cs with the DB and consistency tiers and the same off/observe/annotate modes. No ledger tier: Python records facts from tool results inside the specialist processes, so an orchestrator-side port needs them carried back over A2A. Prose figures are instead checked against the DB rows the answer’s own cards cite. Python’s enforce is refused at startup rather than silently behaving like annotate | Partial | P2 | #33 | |
| 18 | Idempotency on money paths | shared/idempotency.py + idempotency_keys, applied to initiate_return, process_refund, execute_approved_action and checkout | Shared/Idempotency/IdempotencyGuard.cs over the same table, applied at the same four sites. Reserve via ON CONFLICT DO NOTHING, replay a completed reservation, refuse a live duplicate, reclaim one older than 60s, release on failure | Full | — | — | |
| 19 | Rate limiting | shared/rate_limit.py — Redis sliding window on both chat routes, keyed by user and by IP for anonymous traffic | Shared/RateLimiting/SlidingWindowRateLimiter.cs — the same Lua script, applied to both chat routes via an endpoint filter. Fails open | Full | — | — | |
| 20 | Cost estimation and budget ceiling | shared/cost.py + cost_budget_middleware.py, COST_BUDGET_MODE default observe | Shared/Cost/CostEstimator.cs plus a ceiling in SpecialistPipeline, same default | Full | — | — | |
| 21 | Telemetry depth | shared/telemetry.py — traces, metrics and logs to Aspire; auto-instrumentation for httpx, asyncpg and OpenAI; invoke_agent GenAI span convention; trace_id correlated into usage_logs. Emits one custom instrument this repo owns — ecommerce.llm.cost.usd, plus tokens split by direction, from the same per-turn estimate the budget ceiling already computes. Everything else is auto-instrumentation | Shared/Telemetry/TelemetrySetup.cs — traces, metrics and logs to Aspire; auto-instrumentation for ASP.NET Core, HttpClient and Npgsql; same invoke_agent convention and session/conversation enrichment; the same ecommerce.llm.cost.usd and ecommerce.llm.tokens instruments under the same meter name, so one dashboard covers both stacks | Full, except the optional Langfuse sink | P3 | #19 | |
| 22 | Orchestration modes registered | Five: tool, handoff, workflow:pre-purchase, workflow:return-replace, group-chat | The same five. Verified live against a running stack: one question answered in three modes gives the orchestrator’s own composition, the specialist’s unedited answer, and a panel transcript respectively | Full | — | — | |
| 23 | /api/orchestration/* routes | modes, modes/{name}/graph, compare, {run_id}/resume | All four. resume restores the paused workflow from its checkpoint and claims the pending row before executing — Python updates it afterwards, which leaves a window where two clicks both release a refund | Full | — | — | |
| 24 | MCP consumption (client side) | product-discovery and inventory-fulfillment can swap their direct-asyncpg tools for MCPStreamableHTTPTool against the two MCPServer servers, gated by MCP_ENABLED | .NET ships an MCP server (ECommerceAgents.Mcp, real JSON-RPC) but no specialist wires an MCP client, so there is no equivalent swap | Partial | P3 | #19 | |
| 25 | Session + checkpoint backends actually used | MAF_SESSION_BACKEND and MAF_CHECKPOINT_BACKEND drive real providers | Both registered in Program.cs, and checkpointing is now genuinely exercised: workflows write through MAF’s CheckpointManager during a run, which is what makes GET /api/runs/{id}/checkpoints return anything. Registration alone was not enough — the DI entry existed for a while with no consumer | Full | — | — | |
| 26 | Seeder and auth-server | scripts/seed.py (deterministic, random.seed(42)) and the Python auth_server image | The same two Python images, by design. docker-compose.dotnet.yml builds both from ./agents/python. The seeder is the single source of demo data — a second implementation would have to produce byte-identical rows or the two stacks diverge in catalogue content, and the dual-backend Playwright suite asserts against seeded data, so divergence there destroys the parity gate that having two backends exists to provide. OAuth2 is protocol-standard: both stacks validate against a JWKS endpoint and the issuer’s language is invisible to the consumer. Neither service is an agent, so neither demonstrates anything about Microsoft Agent Framework. Cost, stated honestly: the .NET stack cannot start unless the Python image builds | By design | — | plan 16 F5 | |
| 27 | Anonymous multi-turn memory | Not persisted — anonymous storefront conversations have no context at any tier | Same | By design | — | plan 20 | |
| 28 | Langfuse sink | Optional additive exporter alongside OTel | Deliberately not ported. OTel is the primary sink on both stacks and already carries GenAI spans to Aspire; a second exporter would be additive-only and duplicate what is already exported | By design | — | plan 20 | |
| 29 | Refresh-token rotation (#102) | AUTH_MODE=local: /api/auth/refresh returns {access_token, refresh_token}, spends the presented token and revokes the whole family if a spent one is replayed (refresh_tokens table, migration 0003, flag AUTH_REFRESH_ROTATION). AUTH_MODE=oauth does not rotate: the auth-server’s refresh grant relays unchanged (INCLUDE_NEW_REFRESH_TOKEN=False) and the endpoint still returns only access_token. Out of scope for #102 | Same, in RefreshTokenStore over the same table; the oauth-mode limit is identical | Full for local mode; oauth mode not implemented on either stack | P3 | #102 | |
| 30 | OpenAI wire API for LLM_PROVIDER=openai | LLM_API=responses\|chat_completions (default responses): shared/factory.py::build_openai_client picks OpenAIChatClient (POST /responses) or OpenAIChatCompletionClient (POST /chat/completions) — the latter for endpoints with no Responses route (Gemini’s compatible endpoint, some vLLM/Ollama); the replay recorder follows the same switch | ChatClientFactory.CreateChatClient always uses the OpenAI SDK’s ChatClient, which is Chat Completions, honouring LLM_BASE_URL; there is no Responses-API path and no switch. Not a parity gap in capability — .NET already works against Chat-Completions-only endpoints — but the two stacks’ default wire API differs (Python responses, .NET Chat Completions) and LLM_API is ignored by .NET | Partial | — | #96 | |
| 31 | No-key demo tour (#86) | With LLM_PROVIDER=replay and DEMO_TOUR_ENABLED=true, GET /api/demo/tour serves the chip manifest (config/demo/tour.yaml), POST /api/demo/reset resets the tour user, and a prompt with no recorded response ends as a dedicated replay_miss SSE frame (a structured field on /api/chat) rather than an apology. A miss inside a specialist travels as HTTP 424 on /message:send and an event: replay_miss frame on /message:stream | The tour is not ported, by recorded decision; the miss handling is. The .NET stack has no tour endpoints, and its miss text is Python’s fallback DEFAULT_MISS_MESSAGE rather than the tour manifest’s miss_message. The web tour chips detect a backend with no tour at runtime (404) and render nothing. What a .NET stack running LLM_PROVIDER=replay does with a prompt that has no recording is the same as Python: ChatRoutes ends the turn as replay_miss: {message} on /api/chat and an event: replay_miss frame (then metadata, done) on the stream, saves no assistant message and logs no usage, and takes the unanswered user message back out so later turns still hit their recordings (ReplayMissChatTests). A specialist’s miss crosses the hop as HTTP 424 / an event: replay_miss frame on the legacy wire and as a failed task with replay-miss/v1 on A2A 1.0, on both stacks, and the .NET A2AClient raises it instead of returning an apology the orchestrator’s model would answer; the tool loop is ended without another model call, as in Python. Workflow modes (pre-purchase, return-replace) call no model and cannot miss | Partial (tour only) | — | #86 | |
| 32 | Outbox worker, approval SLAs and notifications (D-7, #92/#94) | agents/python/worker/ polls the outbox table (FOR UPDATE SKIP LOCKED, leases, capped backoff, parking); approval reminders, support-to-manager escalation and on_timeout run from it; GET /api/me/notifications and the web bell read what it writes | Not ported, by design. The .NET stack shares the same Postgres database, so the one Python worker (outbox-worker in docker-compose.dotnet.yml too) drains the timers for approvals created by either stack. .NET has no worker of its own and no /api/me/notifications route (the bell shows nothing there). Since D-5n the .NET orchestrator enqueues the same two timers (approval.reminder_due, approval.sla_breached) itself, in the transaction that moves an approval into review (ApprovalRepository, same topics, dedupe keys and payload), and ApprovalCrossStackTests + test_approval_dotnet_rows.py prove the Python handlers process rows .NET wrote. One limit: see row 36 | Python only | — | #92, #94 | |
| 33 | Anthropic (Claude) as LLM_PROVIDER (#96) | LLM_PROVIDER=anthropic + ANTHROPIC_API_KEY (+ ANTHROPIC_MODEL, default claude-sonnet-5-5) builds MAF’s own agent-framework-anthropic connector (1.0.0b261112, beta-only, pinned exactly; needs core ≥ 1.24, repo on 1.26.0) in shared/factory.py::get_chat_client via shared/anthropic_client.py, which raises the connector’s 1024 max_tokens fallback to 4096; the key is checked at construction and named, never its value; valid as a per-agent model.provider and as REPLAY_RECORD_PROVIDER. No embeddings API: with no EMBEDDING_PROVIDER the stack starts, warns once and semantic search uses full-text. Proven by a stubbed-httpx2-transport test only (blocking and streaming tool round trip, usage, factory, embeddings, recorder) — never against the live API. Claude models are unpriced in shared/cost.py | LLM_PROVIDER=anthropic + ANTHROPIC_API_KEY (+ ANTHROPIC_MODEL, default claude-sonnet-5-5) builds the official Anthropic 13.8.0 package’s IChatClient adapter in ChatClientFactory; startup fails naming the missing key; also valid as a per-agent model.provider. Proven by a stub-handler test only (wiring, request/response translation, usage) — never against the live API. Claude models are unpriced in CostEstimator (the repo documents no prices) so cost falls back to the default entry | Full — same settings, default model and embeddings behaviour (different SDKs); neither stack has made a live call | P2 | #96 | |
| 34 | Embeddings decoupled from the chat provider (#96, #83) | EMBEDDING_PROVIDER (openai \| azure \| openai_compatible \| replay), EMBEDDING_BASE_URL, EMBEDDING_API_KEY, EMBEDDING_MODEL, EMBEDDING_DIM; dimension checked against the live column at startup; scripts/reset_embeddings.py changes it | Same settings and the same startup check (EmbeddingDimensionCheck); the reset script is Python and works for both stacks’ database | Full | — | #96 | |
| 35 | Unified approvals API, reviewer edits and request-more-info (D-5a, #92) | GET /api/approvals[/{id}], POST /api/approvals/{id}/decide (approve with edits, reject, request_info), POST /api/approvals/{id}/info and GET /api/me/approvals; gated tool calls and paused returns open policy-routed approvals rows; the legacy resume/approve/deny routes are shims over the one decide; an SLA timeout resumes a paused return as a rejection | Ported (D-5n). Routes/ApprovalRoutes.cs serves the same five routes with the same JSON, status codes and {"detail"} bodies over Approvals/ApprovalsService.cs, on the same approvals / approval_events / outbox tables (no new migration). Same invariants, each with a test (ApprovalRoutesTests, ApprovalRepositoryTests): staff only, never the requester, role at or above the assigned route, edits only for the kind’s editable fields and never above the amount under review, a fenced TTL claim so a decision executes once, claim released when execution fails, request_info round trip, the resumed run executed as the requester with the reviewer recorded separately. HitlGate and the paused-return chat route open a policy-routed approvals row; the legacy /api/orchestration/{run_id}/resume (now staff bounded by the route, was admin-only) and /api/admin/hitl/requests/{id}/approve\|deny are shims over the one decide. The reviewer’s ReturnDecision (edited resolution / amount) now reaches the workflow through the API. Not on either stack: customer confirm (pending_confirm) | Full | — | #92 | |
| 36 | An unattended paused return times out (D-5n, #92) | At the top escalation level the worker queues approval.timeout_apply; orchestrator.approvals_service.expire resumes the paused workflow from its checkpoint with Python’s ReturnReplaceMode as a rejection, so nothing is created, then marks the approval expired | Cannot be done by the shared worker. The worker is Python’s only and resumes with Python’s checkpoint storage; a .NET workflow’s checkpoint is MAF .NET’s JSON (PostgresJsonCheckpointStore), so the resume cannot succeed and the row is retried and parked (reasoned from the two storage implementations, not run end to end). Reminders and the support-to-manager escalation resume nothing and work for .NET approvals; a .NET tool approval expires correctly (the worker only denies the request row). Closing an unattended .NET return takes a manager’s decision, which resumes it in-process. Fixing it needs a .NET handler for approval.timeout_apply (a worker, or a hosted service in the orchestrator that drains that one topic) | Partial (.NET tool approvals expire; .NET workflow returns do not) | — | #92 | |
| 37 | Conformant A2A 1.0 (B-12, B-13, #88) | Every specialist serves the A2A 1.0 JSON-RPC binding at POST /a2a/v1 and a spec agent card (supportedInterfaces, skills from its tools, three extension URIs) beside the unchanged legacy /message:send + /message:stream. A2A_TRANSPORT=legacy\|a2a (default legacy) picks the wire the orchestrator and the handoff mesh call with, through the official a2a-sdk client. Tested with that client over ASGI and a real socket (tests/test_a2a_conformance.py); docs/a2a.md | Ported (B-13). AgentHost.Build serves the same A2A 1.0 JSON-RPC binding at POST /a2a/v1 and a spec agent card beside the unchanged legacy routes, on the official A2A .NET SDK (A2A + A2A.AspNetCore 1.0.0-preview4, spec 1.0, pinned exactly; a preview, grouped in Dependabot). Same contract: SpecialistA2AExecutor runs the same RunAgentWithHistoryStreamingAsync the legacy stream uses, so the model sees identical input; contextId is the session (an SDK-invented id is ignored via ClientProvidedContextId); one answer artifact, append=false then true, last chunk flagged; steps / usage / replay-miss in status metadata under the same three URIs and only when the caller listed them (and echoed in A2A-Extensions); the same auth middleware in front; owner-scoped, bounded task store (OwnedBoundedTaskStore, which also republishes extension metadata into the task because the .NET SDK, unlike Python’s, does not merge it); ActiveTaskLimiter caps; fixed error text; the card lists only tools customer may call (a [RequiresRole] attribute mirrors the RoleGuard.Ensure guards, cross-checked by a test). A2A_TRANSPORT=legacy\|a2a (default legacy) on A2AClient (so the tool router and the handoff mesh too) with the Python client’s rules: registry origin only, no redirects, best-effort cancel of an abandoned stream, retry only what never ran. Tests: A2ASpecialistServerTests, A2AClientTransportTests, and the cross-process check scripts/a2a-interop.sh (official Python client and shared.a2a_client against a real .NET specialist; the official .NET client and A2AClient against a real Python one; keyless, a CI job). The .NET chat route acts on a replay miss as Python’s does (row 31). The mixed-stack compose overlay (docker-compose.mixed.yml, e2e-both-stacks.sh --mixed, B-11) was validated with docker compose config only | Full | — | #88 | |
| 38 | Signed user-context token for inter-agent calls (B-14, #88, #81) | A2A_IDENTITY=headers\|token\|both (default both). The orchestrator signs the user’s identity into a short-lived (5 min) HS256 JWT (shared/identity_token.py: typ=a2a-user-context+jwt, aud = the specialist’s registry name, sub/email/role/sid, act) sent as X-User-Context; AgentAuthMiddleware verifies it: a bad token is refused (never ignored), a header contradicting a valid one is refused, token mode reads no header at all, both falls back to the headers when there is no token. Key: HKDF-SHA256 of A2A_IDENTITY_KEY, else AGENT_SHARED_SECRET (no new IdP). Golden vectors config/identity/testdata/user-context.v1.json. | Ported (B-14), same format and key. Auth/UserContextToken.cs derives the same key and verifies the same golden tokens Python mints; AgentAuthMiddleware resolves identity per the same mode (a specialist passes its registry name as the audience); A2AClient mints per call on both transports. Tests: UserContextTokenTests, A2AClientIdentityTests, and the interop run (a token minted by one stack served by the other; headers alone, a forged header, a token for another specialist, another key and an expired one all refused). Differences: none in behaviour; out-of-range A2A_IDENTITY_TTL_SECONDS / task caps fail at startup on both | Full | — | #88 | |
| 39 | Merchant proposals (M-3, M-4, #93) | GET/POST /api/seller/proposals (plus /run, /{id}, /{id}/decide): deterministic markdown and restock proposals for a seller’s products, judged by the M-1 guards, reviewed line by line by the owning seller through the ordinary approvals row (kind merchant_proposal, source proposal, requester the system actor merchant-ops@system), executed once per line (proposal_line:{id}) after re-checking the guards on live facts; an optional daily run (merchant.daily_run_due, MERCHANT_OPS_SCHEDULE_ENABLED, default off) and SLA reminder/expiry through the outbox worker; web /seller/proposals | Not ported, by recorded decision. The .NET stack has no proposal routes, generator or page. Its approvals inbox shares the database but treats a proposal as absent: every staff route answers the 404 a missing id gets (as Python’s do); the Python worker serves the timers. The merchant-ops agent and its eval dataset (M-2) are not built: they need a recording session | Python only | — | #93 | |
| 40 | Event autonomy: autonomy budgets (V-1, V-2, #94) | An order.shipment_delayed event (outbox row, simulator-injected) is turned by a deterministic rule into a goodwill credit; config/policies/autonomy.yaml says whether the system may act alone (per-action, per-customer, per-order and global daily caps, checked and drawn atomically under an advisory lock) or must open an approval (kind autonomous_action, source event, requester the system actor autonomy@system); every decision is a row in the append-only agent_decisions (who, what, why, the budget it drew on), a credit is an append-only store_credit_ledger entry, and a reversal is a negating entry; POST /api/admin/events/simulate, GET /api/admin/decisions, POST /api/admin/decisions/{id}/reverse; web /admin/decisions. Off unless AUTONOMY_ENABLED; no model is called; docs/event-autonomy.md | Not ported, by recorded decision. The .NET stack has no autonomy engine, routes or page. The approval kind is in the shared approvals.yaml (golden cases run on both stacks), and the Python worker serves the timers and the event for both. A .NET inbox lists an event approval (it only excludes proposal) but refuses every decision on it (approve, reject and request_info) with a 422 “cannot be decided on this stack; use the Python orchestrator”, before anything is claimed and with no state change (request_info used to park it in needs_info, where Python approve then refuses it); the decision belongs to the Python orchestrator. The “reviewer is never the subject” rule is mirrored in .NET AuthorizeDecider. The LLM ops-responder mode (EVENT_AGENT_MODE=agent) is not built: it needs a recording session | Python only | — | #94 | |
| 41 | Return lifecycle after approval: carrier-scan wait, inspection, resolution, timeline (D-9a, D-9b, #95) | With RETURN_LIFECYCLE_ENABLED an approved return pauses at await-carrier-scan until a return.carrier_scanned outbox event resumes it from its checkpoint, or a return.scan_timeout timer expires it; POST /api/admin/returns/{id}/simulate-scan is the only producer. Support then inspects it (/admin/returns, POST /api/staff/returns/{id}/inspect): refund, store credit or replacement, or a denial. See return-lifecycle.md. | Not ported. Each wait needs its own RequestPort node and the SLA worker is Python-only (row 36); recorded rather than ported, as the plan decided. | Python only | — | #95 | |
| 42 | DevUI entry point (B-17, #98) | scripts/devui.py registers the five specialists and two workflows in MAF DevUI, run with uv run --with agent-framework-devui==... so the shared lock is untouched; one dev identity bound from DEVUI_USER_*. See devui.md. | Not ported: DevUI is a Python-only harness. | Python only | — | #98 |
What’s not on this list
Both backends implement the domain fully — an orchestrator plus five specialist agents, A2A routing, the tool-router mode, Postgres-backed checkpointing, OAuth2/JWT auth, guardrails, idempotency on the money paths, rate limiting, and the Aspire-based telemetry pipeline. This matrix tracks the gaps; the shared foundation isn’t repeated here row by row.
Two claims this document used to make and no longer does, because both were false when checked against the code: that neither stack wired its workflows to a live route (both do), and that Python has a magentic_mode.py (neither stack has one).
Out of scope for now
.NET readers should treat the P3 rows as capabilities this backend doesn’t have yet rather than capabilities arriving soon: the remaining eval gaps (the red_team dataset, five of six baselines, and any PR-time gate — the .NET harness exists but is manual-dispatch only), MCP client consumption, and the optional Langfuse sink. Long-term-memory writes are no longer on that list; they are ported. Handoff and group-chat are no longer on that list — both are registered, live and built on MAF’s own orchestration. Magentic is not on it either — it exists in neither stack, so it is not a parity gap at all.
The P2 row is grounding’s missing ledger tier, which is bounded by a real constraint rather than effort: the facts it would check against are produced inside the specialist processes and would have to be carried back over A2A.
Everything else above is Full on both sides. Where .NET is stricter than Python it is noted inline rather than smoothed over — the resume route’s claim-before-execute is the current example.
Source: docs/parity-matrix.md — this page is generated from the repository.