Development Roadmap · Production-Backbone-First

Build sequence — features & phasing

Built in dependency order along the value chain — not a demo we grow into. Each phase has a goal, the features it ships, and a concrete gate that must pass before the next begins. Solo-developer estimates; phases parallelize as the team grows.

Foundations→ Multi-tenancy→ Knowledge→ LLM insight→ Distribution→ Sensor data→ Learning & scale

Build the real system in dependency order · then drive it with sensor data · cloud-cutover gate = backbone real end-to-end (Phases 0–4)

PHASE 0

Foundations & the spine

≈ 3 weeks

Spine

The skeleton stands — one event ingested and traceable end-to-end, no agent, no UI.

Repo, build & CI — CPM, strict build, Aspire AppHost + emulators

Core SDKs — Contracts, Adapter, Variants, Persistence

Event spine — Event Hubs + StateProjection (archive + project, idempotent)

Audit + telemetry — immutable Blob; enforced OTel fields; module-metrics

GateAn injected event is archived + projected and traceable by correlationId; telemetry & variant-isolation tests pass.

PHASE 1

Multi-tenancy & identity

≈ 3 weeks

Backbone

Real isolation, real per-tenant config, real identity — the thing the prototype never had.

SQL config layer — Tenants, Stores, RoutingPolicies, Agents, Variants

TenantResolver — fail-closed; ITenantContext everywhere

Identity — Entra External ID + local resolver; roles

Seeding — the three demo tenants + contexts

GateMulti-tenant isolation suite passes (P0 on failure); per-tenant vertical + routing read from SQL, not constants.

PHASE 2

Knowledge & ingestion

≈ 3 weeks

Knowledge

The system holds & retrieves scoped knowledge — the substrate insight reasons over.

IKnowledgeRetriever — Azure AI Search / local vector index

Scope model — platform → enterprise → store; fail-closed filter

Ingestion — chunk → embed → index; re-index on change

Prompts SDK + registry; the LlmProvider embedding core

GateScoped, layered, isolated retrieval (store over enterprise over platform); knowledge-isolation test passes; idempotent re-ingest.

PHASE 3

LLM insight generation

≈ 4 weeks

Insight

The agent produces real, audited insights from knowledge + context — solicited first, then the deterministic floor.

LlmProvider — real pinned models; full LlmCallRecord audit

Agent runtime — composition, context, validation, memory, tools

Conversation — real agent path (chat), streamed + persisted

SafetyNet — the never-miss floor + agent-down fallback

GateA grounded, cited answer; a schema-valid, quantified suggestion; every LLM call writes a complete immutable record.

PHASE 4

Recommendation distribution

≈ 4 weeks

Distribution

Insights reach real clients with real auth and real delivery. The cloud-cutover gate.

Router — SQL policy; targetExpression; escalation; durable retry

Delivery — web (SignalR) + push (Notification Hubs)

Client API — suggestions, actions, delegation, chat · real auth

React Native client — receive · act · dismiss · delegate · ask

GateA suggestion reaches a specific user on a real channel and is acted on; full lifecycle audited & traceable.

↑ Cloud-cutover gate — backbone real end-to-end (Phases 0–4)

PHASE 5

Sensor data ingestion

≈ 4 weeks

Sensor data

Real events flow at volume — the unsolicited, event-driven funnel lights up.

InterestingnessDetector — learned baselines (needs volume)

Simulator — headless event source / load & test harness

Real adapters — weather + local events (OpenWeather, Eventbrite)

Video sub-track — cloud-VLM cascade as an Adapter variant

GateA realistic stream drives the full funnel under load — no loss, no stalls, every step traceable; baselines learn over a multi-day run.

PHASE 6+

Learning, scale & polish

ongoing

Learning & scale

The platform improves itself, and hardens for scale. Preconditions (audit + versioning) built from day one.

Experiments + backtest — A/B, the backtest-before-canary gate

Prompt evolution — weekly outcomes → diffs → ship

Scale — ADX, multi-region, silo automation, multi-agent

Channels & demo — earpiece (PTT); the optional 3D observatory

GateContinuous — guardrail-gated experiments auto-promote; no code deploy to add "things to look for."