Skip to content

Increment I0: Readiness

Generated from the architecture model

This page is rendered from model/**/*.yaml by tools/docs_model during mkdocs build. Edit the YAML, not this page; hand-written design lives on the linked service, platform and plane pages.

A design artefact, not a tracker

This backlog is generated from model/backlog/ and validated against the architecture model. No work item exists in any tracker, and no item carries a date, an estimate or an assignee (ADR-0029).

Outcome. Every repository of the first outcome scaffolds from its template and builds, and one call chain carries a trusted tenant and project scope from the edge to a service.

Depends on: nothing · Elaboration: stories and tasks · Azure DevOps CSV of this increment

Demonstrations

  • Each first-outcome repository exists, builds and runs its template tests in its pipeline.
  • A request with a token of the Identity Platform reaches a service with tenant and project scope, and a request without scope is refused.
  • The contracts package is published and consumed by two services.

Services delivered in this increment

No service is delivered in this increment.

Stub register

No stub is declared in this increment.

Before development

Template and library work of this increment, done first: these features change the templates and shared libraries the Factory scaffolds from and builds on, and none delivers a Factory service. Every task under them carries the tag phase:before-development.

Feature Repositories State Tasks
AIFACTORY-FEAT-096 Agent host template: one execution port and Factory scope ConnectSoft.AI.SoftwareFactory.AgentTemplate elaborated 15
AIFACTORY-FEAT-097 AI and Factory libraries: scope in contracts, Anthropic adapter, durable base ConnectSoft.Extensions.AI
ConnectSoft.Extensions.AI.AgentsFramework
ConnectSoft.Extensions.AI.Factory
ConnectSoft.Extensions.AI.Factory.Abstractions
ConnectSoft.Extensions.AI.Factory.Messaging
ConnectSoft.Extensions.AI.Factory.Messaging.MassTransit
elaborated 43
AIFACTORY-FEAT-098 Model Context Protocol library: authenticated by default ConnectSoft.Extensions.ModelContextProtocol elaborated 18
AIFACTORY-FEAT-099 SaaS libraries: tenancy filters for Orleans grains ConnectSoft.Extensions.Saas elaborated 18
AIFACTORY-FEAT-100 Tenancy integration: tenant resolution for the Factory ConnectSoft.Saas.TenantsTemplate elaborated 11
AIFACTORY-FEAT-153 Agent host template: parameterized agent identity and a neutral exemplar ConnectSoft.AI.SoftwareFactory.AgentTemplate elaborated 19
AIFACTORY-FEAT-154 Agent host template: Factory agent base, handoff envelope and lifecycle stages ConnectSoft.AI.SoftwareFactory.AgentTemplate elaborated 21
AIFACTORY-FEAT-155 Agent host template: model access through the Factory and the Orleans messaging profile ConnectSoft.AI.SoftwareFactory.AgentTemplate elaborated 16
AIFACTORY-FEAT-156 Agent host template: generated-solution gate and a publishable package ConnectSoft.AI.SoftwareFactory.AgentTemplate elaborated 16
AIFACTORY-FEAT-157 Base template: the Factory service profile ConnectSoft.AzurePipelines
ConnectSoft.BaseTemplate
elaborated 25
AIFACTORY-FEAT-158 Base template: open consumer findings closed before the first scaffold ConnectSoft.AzurePipelines
ConnectSoft.BaseTemplate
elaborated 25
AIFACTORY-FEAT-159 API gateway template: the platform gateway profile ConnectSoft.ApiGatewayTemplate elaborated 19
AIFACTORY-FEAT-161 Identity template: the Factory role model with per-project assignments and delegation records ConnectSoft.AuthorizationServerTemplate
ConnectSoft.IdentityTemplate
elaborated 18
AIFACTORY-FEAT-162 Authorization server template: the Factory token contract, workload identity and delegation ConnectSoft.AuthorizationServerTemplate
ConnectSoft.AzurePipelines
elaborated 31
AIFACTORY-FEAT-163 SaaS Tenants template: descriptor, lifecycle, envelope and isolation before the Factory resolves tenants ConnectSoft.Saas.TenantsTemplate elaborated 22
AIFACTORY-FEAT-171 Worker template: the Factory worker profile on the Orleans messaging profile ConnectSoft.WorkerTemplate elaborated 21
AIFACTORY-FEAT-172 Workers.Runtime library: the worker engine published and shaped for Factory services ConnectSoft.Workers.Runtime
ConnectSoft.WorkerTemplate
elaborated 17
AIFACTORY-FEAT-175 Observability libraries: the Factory telemetry conventions as one registration ConnectSoft.Extensions.Observability
ConnectSoft.Extensions.Telemetry
elaborated 23
AIFACTORY-FEAT-183 Library template: target frameworks, a manifest and Factory diagnostics for generated libraries ConnectSoft.AzurePipelines
ConnectSoft.LibraryTemplate
elaborated 23

Features by epic

Engineering readiness

Feature Phase State Route PBIs Tasks
AIFACTORY-FEAT-088 Repository and pipeline conventions for one repository per service
Thirty repositories are created for the first outcome and sixty-five for the whole system. This feature fixes how a repository is named, created, scaffolded, built and released, so that every later feature can say 'create the repository' and mean the same steps (ADR-0028), and it creates and scaffolds every first-outcome repository in I0 from its template at the pinned version with a green template pipeline, so that the I1 features start from a repository that exists (D140).
development elaborated solution-architect 10 47
AIFACTORY-FEAT-089 Trusted tenant and project scope from the edge to a service
Every call in the Factory carries a tenant and project scope that was established once, at the edge, from a token of the Identity Platform, and no service trusts a scope a caller merely claims. This is the first capability every other one depends on.
development elaborated backend-developer 4 12
AIFACTORY-FEAT-090 Contracts package from the published schemas
The run envelope, the topic names, the descriptors and the JSON schemas of this repository are published as one versioned contracts package, so that two services never copy a contract.
development elaborated backend-developer 5 17
AIFACTORY-FEAT-091 Durable execution substrate verified against pinned versions
ADR-0024 chose Orleans grains with the Agent Framework for durable execution without checking the framework's durable extension against the versions the estate pins. This feature proves the substrate with one run that survives a process restart.
development elaborated solution-architect 3 7
AIFACTORY-FEAT-092 Local development environment for a Factory service
A developer or a coding agent can run any first-outcome service locally with its store, messaging and identity, from documented steps, without touching a shared database.
development elaborated devops-engineer 5 14
AIFACTORY-FEAT-093 Command-line client for the first outcome
The first outcome is used through the control plane API and a small command-line client: submit a vision, follow a run, approve a recipe and approve a change proposal. Studio follows in a later increment. I0 delivers the repository, the skeleton and the sign-in (authorization code with PKCE by default, device code as a switch); the commands are the I1 feature command-line-client-commands (owner decision D117).
development elaborated backend-developer 3 8
AIFACTORY-FEAT-094 Import of the backlog draft by the owner
Every owner decision the first wave depended on is recorded: the derived decisions D70, D71 and D74 and the stub register of the first outcome (D80), the Scrum process (D81), the waiver that lets Draft releases run before the evaluation gate exists (D83) and the import without an area path (D85). One act stays with the owner: importing the draft into Azure DevOps, because no session of the Factory design work has a connection to it.
development elaborated human-approval 4 8

Ecosystem component extensions

Feature Phase State Route PBIs Tasks
AIFACTORY-FEAT-096 Agent host template: one execution port and Factory scope
The agent host template carries the Factory scope on every entry point and converges its lifecycle, MCP, REST and development entry points on one execution port, so that every run enters the same way. AgentRuntimeService and WorkflowEngineService are scaffolded from it. Component: AI Agent host template (extend).
before development elaborated backend-developer 4 15
AIFACTORY-FEAT-097 AI and Factory libraries: scope in contracts, Anthropic adapter, durable base
The Factory libraries carry tenant and project scope in their contracts, gain an Anthropic model adapter (decision D16), and expose the run, step and attempt abstractions the durable runtime persists. The libraries are verified to build and test as they are before they are extended. Component: Extensions.AI + AgentsFramework + Factory libraries (extend).
before development elaborated backend-developer 10 43
AIFACTORY-FEAT-098 Model Context Protocol library: authenticated by default
The Model Context Protocol library authenticates every server and client call by default and passes the caller's scope to the governed tool executor, so that no tool path bypasses policy. Component: Extensions.ModelContextProtocol (extend).
before development elaborated backend-developer 5 18
AIFACTORY-FEAT-099 SaaS libraries: tenancy filters for Orleans grains
The SaaS extension libraries resolve the tenant from the trusted scope inside Orleans grains and apply tenant filters to grain persistence and messaging, as they already do for HTTP requests. Component: Extensions.Saas.* libraries (extend).
before development elaborated backend-developer 5 18
AIFACTORY-FEAT-100 Tenancy integration: tenant resolution for the Factory
The Factory resolves its tenants, editions and feature entitlements from the SaaS Tenants service instead of owning them. The first outcome needs tenant resolution only; editions and entitlements follow with commercialisation. Component: SaaS Tenants service (extend).
before development elaborated backend-developer 4 11
AIFACTORY-FEAT-153 Agent host template: parameterized agent identity and a neutral exemplar
A generated agent host carries the identity of its agent in its classes, manifest and MCP surface. Today the template rewrites only the namespace prefix: every generated host ships classes named SampleFactoryAgent*, the MCP method InvokeSampleFactoryAgent, demo weather and string tools switched on by default, and an exemplar whose logic is demo analytics with hard-coded figures (Docs/Generic Agent Audit Report.md of the template, gaps 1, 2, 5 and 7). AgentRuntimeService and WorkflowEngineService cannot be scaffolded from a host that is named after the sample. Component: AI Agent host template (extend).
before development elaborated backend-developer 4 19
AIFACTORY-FEAT-154 Agent host template: Factory agent base, handoff envelope and lifecycle stages
The template has no generic agent abstraction and no event-driven handoff contract: the only agent is the concrete demo, the messaging model carries one create command and one created event, and no run, attempt or handoff event travels with the trace, blueprint and origin of the agent (Docs/Generic Agent Audit Report.md of the template, gaps 3 and 4). This feature adds the Factory agent base that every scaffolded agent derives from, the accepted envelope with the Factory scope on every message, and the lifecycle stages the runtime needs, Cancelled included. It builds on the single execution port of the earlier feature. Component: AI Agent host template (extend).
before development elaborated backend-developer 4 21
AIFACTORY-FEAT-155 Agent host template: model access through the Factory and the Orleans messaging profile
The template reaches model providers directly through its provider switches (Azure OpenAI, OpenAI, Ollama, Azure AI inference) and executes tools inside the host, while the Factory allows model calls only through ModelRouterService and tool execution only through ToolAdapterService (ADR-0028, single-entry rules). Its messaging switch offers MassTransit and NServiceBus but not the Orleans outbox and inbox adapter the runtime uses (ADR-0024). This feature adds the switches a Factory agent host is scaffolded with: a model client that routes through the model gateway and returns a receipt, a tool client that calls the tool gateway, and the Orleans messaging profile. The Anthropic adapter itself is library work of the earlier feature. Component: AI Agent host template (extend).
before development elaborated backend-developer 4 16
AIFACTORY-FEAT-156 Agent host template: generated-solution gate and a publishable package
The last alignment pass of the template records a blocking generation defect inherited from the base template (a persistence provider substitution that leaves an unterminated JSON string in the generated configuration), stale symbols in the agent metadata, a submodule behind the base template, and a package publication that stays blocked until the generated cases pass their configuration smoke tests (Docs/AgentTemplate-Alignment-Verification.md of the template). The two Agent Mesh services are scaffolded only from a published package whose generated solution builds and passes. Component: AI Agent host template (extend).
before development elaborated backend-developer 4 16
AIFACTORY-FEAT-157 Base template: the Factory service profile
Forty-six Factory services are scaffolded from the base template (D94) and deploy alone (ADR-0028), so the work a host did once is done per service by the scaffold. The profile a Factory service is generated with: the Orleans messaging adapter for the outbox and inbox with the accepted envelope, the tenant and project scope read from the token and propagated to every call and message, token validation against the authorization server with the Factory roles as claims, a REST and gRPC surface described by descriptors, health and readiness endpoints, and telemetry that carries run and attempt correlation. A service scaffolded with the profile builds and passes unchanged, which is the acceptance of the readiness checklist. Component: BaseTemplate (extend).
before development elaborated backend-developer 6 25
AIFACTORY-FEAT-158 Base template: open consumer findings closed before the first scaffold
The base template keeps a register of findings reported by its consuming templates (Docs/Consumer-Reported-Findings.md). Four are open: a test session timeout that can silently truncate a run, so that every green result is suspect until it is audited; three vulnerable transitive dependencies, one of them High, carried by Hangfire and Pulumi; the QueryModel symbol without an update path for the consuming templates; and no sync path for the Scripts folder into them. The agent host template also records a generation defect inherited from the base template (a persistence provider substitution that drops a closing quote). The Factory scaffolds from the base template only after these are closed. Component: BaseTemplate (extend).
before development elaborated backend-developer 6 25
AIFACTORY-FEAT-159 API gateway template: the platform gateway profile
The fourteen platform gateways and the Studio backend-for-frontend are scaffolded from the API gateway template (ADR-0028, D73): they validate tokens and scopes, route public REST and internal gRPC calls to the services they front, and own no business state. The template is a custom BFF gateway with controllers, use cases and named clients; it has no profile that generates the route table of a platform from the fronts list of the model, no scope validation that refuses a call outside the tenant and project of the token, and no guard against business state. Component: API Gateway template (extend).
before development elaborated backend-developer 5 19
AIFACTORY-FEAT-161 Identity template: the Factory role model with per-project assignments and delegation records
The Identity microservice owns accounts, credentials, MFA, memberships and roles for the Factory (D18, canonical ADR-0101), and the Authorization Server issues the seven Factory roles as claims from what Identity holds (ADR-0015). The Identity template carries today a flat user, role and claim model: a role is not bound to a project, Platform admin is not a tenant-wide role, and there is no record of a delegation with grantor, grantee, scope, expiry and reason. The template's own findings page records that the multi-valued claims contract (ServiceModel 1.1.x) is promoted and consumed, so repeating role claims can travel; what is missing is the model behind them. Component: Identity microservice (extend).
before development elaborated backend-developer 5 18
AIFACTORY-FEAT-162 Authorization server template: the Factory token contract, workload identity and delegation
The Authorization Server is the sole token issuer of the Factory (canonical ADR-0101, ADR-0008). Its template issues standard OpenID Connect tokens with tenant claims, but not yet what the Factory needs on every call: role claims scoped to a project, audiences for the Factory gateways, registered Factory scopes, client-credential identities for services and agents (workload identity, D44) and the RFC 8693 actor claim that lets an agent act for a person with the delegated scope (ADR-0023). The template's findings page records the delegation gap with two leads, a seeded service client that shares the development secret, a missing Scripts sync guard and the stronger test-completeness check the Identity template already has. Component: Authorization Server (extend).
before development elaborated backend-developer 8 31
AIFACTORY-FEAT-163 SaaS Tenants template: descriptor, lifecycle, envelope and isolation before the Factory resolves tenants
The Factory resolves its tenants from the SaaS Tenants service from the first increment (FEAT-100) and every generated SaaS product gets its product tenants from the same template (GeneratedSaasFoundations). The template's own gap backlog (saas-EPIC-TEN) is not started: the JSON descriptor and the code disagree, the lifecycle saga covers creation only while the Factory needs Suspended and Decommissioned, integration events carry no common envelope, the Orleans write path is undecided and the architecture tests are placeholders. The two-tenant isolation recipe (OP-020 of the Entitlements template) has no fixture yet. What the Factory needs before FEAT-100 is taken from that backlog; the rest stays with the template. Component: SaaS Tenants service (extend).
before development elaborated backend-developer 6 22
AIFACTORY-FEAT-171 Worker template: the Factory worker profile on the Orleans messaging profile
The runtime worker, the reconcilers and the dispatchers of the Factory are scaffolded from the worker template (AgentRuntimeService names it). The template's own control-plane backlog (docs/Control Plane) has landed drain and work-aware readiness, the idempotency store, the worker-owned failed-work record, the job catalog with Hangfire and PeriodicTimer adapters, the singleton lease, the shard filter, the ops surface and the MCP tools, so the Factory inherits a real worker. What it does not have is the Factory's shape: its trigger adapters are MassTransit, NServiceBus, Hangfire, PeriodicTimer and config-only Azure queues, while Factory messages travel on the Orleans messaging profile under the accepted envelope (ADR-0012, ADR-0014, ADR-0024); failed work and processed messages carry no tenant or project; the WorkerOps policy is the template's own rather than the Factory operator role of the token contract; and three of its own gaps stay open (the Jobs table is not the runtime catalog, the bound Scale options are missing from the generated settings, Hangfire recurring execution skips the lease). Component: WorkerTemplate (extend).
before development elaborated backend-developer 6 21
AIFACTORY-FEAT-172 Workers.Runtime library: the worker engine published and shaped for Factory services
The worker template's engine already lives in its own repository and package, ConnectSoft.Workers.Runtime (B-F06): options, drain, idempotency store, failed-work model and sinks, job catalog and lease, IWorkTrigger, shard filter and metric names, with the ASP.NET host, Hangfire dashboard, MCP and Pulumi kept in the template. Its status page records that the package pipeline is not created and the template cannot restore it from the feed. The Factory's base-template services with background loops (environment promotion, pipeline polling, retention sweeps, outbox maintenance) would each write their own drain, idempotency and lease; they register this engine instead, once it carries scope and the envelope identifiers in its contracts. Component: WorkerTemplate (extend), library ConnectSoft.Workers.Runtime.
before development elaborated backend-developer 5 17
AIFACTORY-FEAT-175 Observability libraries: the Factory telemetry conventions as one registration
Sixty-plus Factory services emit traces, logs and metrics through the Extensions.Observability and Extensions.Telemetry libraries, which carry OpenTelemetry, health and metrics wiring but know nothing of a run, a step, an attempt, an agent, a tenant or a project. Without a shared convention each service would write its own enricher and the Studio and the dashboards would correlate nothing. The libraries gain one registration that enriches every signal from the scope accessor and the run event envelope, the health and meter conventions the worker and aggregator templates already follow, and the rule of ADR-0019 that no prompt, completion or tool output reaches telemetry by default. Component: Observability libraries (extend).
before development elaborated backend-developer 5 23
AIFACTORY-FEAT-183 Library template: target frameworks, a manifest and Factory diagnostics for generated libraries
The contracts package (FEAT-090), the gateway client packages (FEAT-178) and every Backend Library module of a generated product (blueprint backend-library, workflow generate-libraries) are scaffolded from the library template (connectsoft-library). The template ships a multi-target class library with optional dependency injection, logging, options binding, metrics and an ActivitySource sample, MSTest, central package management, analyzers, an Azure pipeline and a MkDocs layout; its own pages record that the Framework parameter is a documentation moniker that does not change TargetFrameworks, that the pipeline variables live outside the template parameters, and that eighteen existing libraries still await the alignment checklist (analyzers Include, stylecop.json, .slnx, MkDocs) the template defines. A library generated for the Factory needs one parameter that sets its target frameworks, a manifest the template registry imports, samples on the Factory diagnostics names, and a pipeline that publishes to the Factory feed with the pipeline results the quality gates expect. Component: Library template (extend).
before development elaborated backend-developer 6 23

Outcome verification

Feature Phase State Route PBIs Tasks
AIFACTORY-FEAT-138 Demonstrate I0: Readiness
The outcome of increment I0 is demonstrated end to end and the evidence is recorded: Every repository of the first outcome scaffolds from its template and builds, and one call chain carries a trusted tenant and project scope from the edge to a service. Demonstrations: Each first-outcome repository exists, builds and runs its template tests in its pipeline. A request with a token of the Identity Platform reaches a service with tenant and project scope, and a request without scope is refused. The contracts package is published and consumed by two services.
development elaborated qa-engineer 4 11

Requirements this increment touches

None directly.