Skip to content

🌱 ConnectSoft Incubator Agent

🎯 Purpose

The ConnectSoft Incubator Agent supports exploration and optionality in the ConnectSoft AI Software Factory: raw pitches, spikes, experiments, and proactively generated candidate ideas. It applies lightweight stage-gates so weak concepts exit cheaply and promising ones can graduate—with optional handoff to the Vision Architect Agent when the organization commits to a full software vision.

The Incubator is not the mandatory first step of every initiative. It can run standalone, on a schedule (e.g. cron), or in response to events, including while other factory work is already in progress (e.g. portfolio-level or platform-level ideation).

In short: The Incubator explores, normalizes, and gates ideas—and may surface new ideas on a cadence—without replacing structured vision, BRD, roadmap, or backlog work owned by other planning agents.

📋 Responsibilities

Responsibility Description
Intake normalization Turn informal pitches into a consistent Incubator Brief structure (problem sketch, users, constraints, unknowns).
Stage-gates Apply go / park / kill / continue-experiment decisions with traceable rationale.
Idea pool maintenance Maintain or refresh a versioned idea pool artifact (candidates, status, links to signals).
Proactive ideation On scheduled or policy-mapped runs, consume configured signal feeds and propose candidate ideas (with confidence and review flags).
Stale exploration nudges Flag dormant items (no activity past threshold) for human or agent follow-up.
Optional promotion When criteria are met, emit IdeaPromotedToVision so the Vision Architect can produce a full Vision Document.
Traceability Embed trace IDs, source mode (intake / scheduled / event), and links to inputs in all artifacts and events.

🏛️ Position in the Entire ConnectSoft AI Software Factory Process

The Incubator sits in the Vision and Product Planning cluster for documentation discoverability. Activation is not strictly sequential with Vision Architect → Product Manager → Product Owner → Business Analyst.

flowchart TD
    subgraph Modes["Activation (any combination)"]
        Human["Human / agent pitch"]
        Cron["Scheduled run"]
        Ev["Mapped platform events"]
    end

    Human --> Incubator["ConnectSoft Incubator Agent"]
    Cron --> Incubator
    Ev --> Incubator

    Incubator --> Brief["Incubator Brief / idea pool update"]
    Brief --> Gate{"Stage-gate"}
    Gate -->|park / kill / experiment| Pool["Idea pool / audit trail"]
    Gate -->|promote| Promo["IdeaPromotedToVision"]
    Promo --> VA["Vision Architect Agent"]
    VA --> VD["Vision Document → planning cluster"]
Hold "Alt" / "Option" to enable pan & zoom
  • Upstream input: Unstructured or semi-structured pitches, signal bundles (scheduled runs), policy-mapped events.
  • Downstream output (optional): IdeaPromotedToVision ➔ Vision Architect produces a Vision Document; many runs end in the idea pool without invoking Vision Architect.

🏷️ ConnectSoft Platform Principles Alignment

  • Domain-Driven Design: Incubator Briefs and idea-pool entries carry domain tags and trace IDs for later bounded-context alignment when promoted.
  • Event-Driven Architecture: Emits IncubatorStageGateCompleted, IncubatorCandidateIdeasPublished, IdeaPromotedToVision, and related events with versioned payloads.
  • Cloud-Native and Multi-Tenant: Schedules, allowlists, and artifact storage respect tenant/project isolation and quotas.
  • AI-First Modularization: Skills (intake, validation, signal synthesis) compose into activation-specific pipelines.
  • Governed autonomy: Cron and batch ideation are bounded by frequency caps, deduplication, and human-review policy.

🎯 Example Scenarios Supported

Scenario Supported? Notes
Ad-hoc pitch from a product lead ✅ On-demand intake + stage-gate
Weekly portfolio “idea sweep” from telemetry themes ✅ Scheduled run + candidate list
Post-incident theme → exploration backlog ✅ Event-driven when policy maps
Hackathon outcome → park or promote ✅ Intake with experiment metadata
Platform team ideation without a product line ✅ Standalone mode
Skip Incubator entirely for a committed initiative ✅ Factory allows direct Vision Architect activation

📥 Inputs

Input type Description Example
Raw pitch Freeform text, optional links, lightweight attachments “Explore a connector for X in our edition Y.”
Signal bundles Structured or semi-structured inputs for scheduled runs Aggregated backlog themes, digest exports
Policy context Stage-gate rules, allowlists, promotion thresholds, cron definitions YAML/JSON policy per tenant
Existing idea pool Prior briefs and statuses Snapshot ref for deduplication / dormancy

📤 Outputs

Output type Description Format / example
Incubator Brief Problem sketch, users, constraints, unknowns, next experiment, gate outcome Markdown + JSON
Idea pool updates Versioned candidates with status and trace IDs Artifact store / list
Gate record Machine-readable decision + rationale (mandatory for park/kill) JSON
Events See Events emitted and consumed and Example event schemas below Event bus JSON

🏛️ Visual: High-Level Data Flow for Inputs and Outputs

flowchart TD
    subgraph In["Inputs"]
        Pitch[Raw pitch]
        Sig[Signal bundles]
        Pol[Policy / schedule]
        Pool[Existing idea pool]
    end

    Pitch & Sig & Pol & Pool --> Incubator["ConnectSoft Incubator Agent"]
    Incubator --> BriefOut["Incubator Brief"]
    Incubator --> PoolUp["Idea pool updates"]
    Incubator --> Bus["Event Bus"]
    Bus --> VisionArch["Vision Architect (optional)"]
    Bus --> Audit["Audit / observability"]
Hold "Alt" / "Option" to enable pan & zoom

⚡ Activation modes

Mode Intent
On-demand / intake A human or upstream agent submits a raw pitch; the Incubator normalizes and runs a stage-gate.
Scheduled (cron) Periodic execution: scan configured signal feeds, generate or refresh candidate ideas, update the idea pool, flag dormancy.
Event-driven React when policy maps factory or platform events (e.g. new segment, catalog update, incident theme) to Incubator processing.
Standalone Portfolio- or platform-level ideation without being wired as step zero for a specific product line.

🕐 Triggers, scheduling, and operating modes

On-demand

  • Trigger: Explicit submission (UI, API, or agent handoff) with raw text and optional attachments.
  • Behavior: Run Incubator Intake & Stage-Gate Skill, then persist brief and gate outcome.

Scheduled (cron)

  • Trigger: Time-based schedule (e.g. weekly portfolio review, nightly signal digest)—configured per tenant/project.
  • Inputs (configurable): Aggregated telemetry summaries, backlog theme exports, market/tech digests (as approved artifacts).
  • Behavior:
    • Ingest only allowlisted feeds; respect rate and token budgets.
    • Produce candidate idea records (title, hypothesis, signal refs, suggested next experiment, confidence).
    • Apply human-review policy: e.g. auto-publish to internal “candidates” lane vs draft-only until a human approves (configurable).
  • Guardrails:
    • Frequency caps (max runs per day/week per scope).
    • Deduplication against recent idea pool entries (semantic or id-based).
    • No promotion to Vision Architect from scheduled runs unless a separate explicit promotion action occurs (human or policy).

Event-driven

  • Trigger: Events registered in orchestration policy (examples: configuration changes, template catalog updates—exact mapping is deployment-specific).
  • Behavior: Same artifact and event patterns as on-demand or scheduled, tagged with source_event_id.

Observability for all modes

  • Emit traces with incubator_run_id, activation_mode, schedule_id (if any), and counts of ideas created, updated, or closed.

✍️ Example System Prompts Used by ConnectSoft Incubator Agent

System prompt (summary):

You are the ConnectSoft Incubator Agent. You explore and gate ideas; you do not produce a full Vision Document. You honor activation mode and policy (cron limits, promotion rules). You always record gate rationale and emit IdeaPromotedToVision only when approval policy allows—not VisionDocumentCreated.

The full initialization block appears under System Prompt (Initialization) below.

🧩 Example Input Prompt Template

ConnectSoft Incubator Agent — Input Template

Activation mode: {on_demand | scheduled | event_driven | standalone}
Raw pitch or signal summary:
"{content}"

Optional context:
- Submitter / portfolio: {submitter_context}
- Constraints hint: {constraints_hint}
- Idea pool snapshot ref: {idea_pool_snapshot_ref}
- Source event id (if any): {source_event_id}

Instructions:
- Normalize into an Incubator Brief structure.
- Apply stage-gate policy; record rationale for every outcome.
- If promote-ready, prepare handoff checklist for Vision Architect (do not emit VisionDocumentCreated).
- Emit the appropriate Incubator events after validation passes.

🧾 Expected Output Format Example

# Incubator Brief

## Hypothesis (one line)
Small clinics will adopt a lightweight scheduling add-on if it integrates with their existing EHR export.

## Problem sketch
Scheduling is fragmented; staff double-book and no-show follow-up is manual.

## Provisional users / segments
- Clinic admin (primary) — flag: needs_research
- Locum physicians — assumed

## Constraints and assumptions
- Must not store PHI in incubator artifact — **validated** policy
- 8-week experiment budget — **assumed**

## Unknowns
- Integration depth with top 3 EHR vendors
- Pricing sensitivity

## Smallest next experiment (timeboxed)
- 5 interviews + 1 paper prototype — 2 weeks

## Gate outcome
continue_experiment

## Rationale
Clear pain; unknowns tractable with cheap experiment; no regulatory red flags in brief.

## Traceability
- trace_id: `inc-20250428-abc`
- activation_mode: `on_demand`

{
  "artifactType": "IncubatorBrief",
  "trace_id": "inc-20250428-abc",
  "activation_mode": "on_demand",
  "hypothesis": "Small clinics will adopt...",
  "gate_outcome": "continue_experiment",
  "gate_rationale": "Clear pain; unknowns tractable...",
  "promote_ready": false,
  "metadata": {
    "session_timestamp": "2025-04-28T10:00:00Z",
    "confidence_score": 0.78
  }
}

📚 Knowledge Base

Knowledge area Description
Innovation and experiment patterns Hypothesis framing, cheap tests, kill/park criteria
ConnectSoft factory ontology How Incubator Briefs relate to Vision Documents and planning agents
Signal taxonomy Allowed signal bundle types for scheduled runs (per deployment)
Historical idea pool Semantic retrieval to avoid duplicates and revive related threads
Policy packs Stage-gate rules, promotion thresholds, cron caps per tenant

🛠️ Technologies

Technology Purpose
Semantic Kernel (.NET) Agent orchestration, skills, plugins
OpenAI / Azure OpenAI Service Language reasoning and synthesis
Vector database (optional) Similarity search over past briefs and candidates
Azure Storage / artifact store Versioned Incubator Briefs and idea pool
Azure Event Grid / Kafka Emit Incubator and handoff events
Scheduler / orchestration Cron and event-triggered runs with quotas
OpenTelemetry, Serilog Traces, logs, metrics

🏗️ Visual: Technology Stack for ConnectSoft Incubator Agent

flowchart TD
    SK[Semantic Kernel] --> LLM[LLM Service]
    SK --> Store[Artifact / idea pool storage]
    SK --> Vec[(Vector DB optional)]
    SK --> Bus[Event Bus]
    Sched[Scheduler / orchestration] --> SK
    SK --> OTel[OpenTelemetry / logging]
    Bus --> VA[Vision Architect Agent]
Hold "Alt" / "Option" to enable pan & zoom

📜 Example Technology Callouts

Info

Semantic Kernel chains skills such as Incubator Intake & Stage-Gate, Structure Validator, and Signal Synthesis (scheduled mode).

Warning

Scheduled runs must enforce allowlists and token budgets per tenant to prevent unbounded cost and noise.

Tip

Vector memory improves deduplication and “related idea” surfacing before publishing IncubatorCandidateIdeasPublished.

🔄 Internal Process Flow

Step Description
1. Activation Resolve mode: on-demand, scheduled, event-driven, or standalone.
2. Context load Load policy, idea pool snapshot, allowlisted signals (if any).
3. Normalize / synthesize Intake skill and/or signal synthesis for batch candidates.
4. Deduplication Compare against recent pool entries; flag duplicates.
5. Stage-gate Apply policy; record mandatory rationale.
6. Assemble artifacts Incubator Brief, gate record, pool updates.
7. Self-validation Run validation skill chain (structure, rationale, policy).
8. Emit events IncubatorStageGateCompleted, batch events, optional IdeaPromotedToVision.
9. Observability Trace, log, metrics for the run.
10. Human checkpoint (optional) Review queue for low confidence, sensitive domain, or cron draft policy.

🧩 Modular Skills Invoked in Process

Skill Purpose
Incubator Intake & Stage-Gate Skill Normalize pitch → brief + gate (detailed below)
Signal synthesis skill Combine allowlisted feeds → ranked candidate ideas (scheduled)
Dormancy scan skill Detect stale pool items; suggest nudge or closure
Structure / rationale validator Ensure mandatory fields and rationale for gate outcomes
Promotion readiness checker Verify handoff checklist before IdeaPromotedToVision

Incubator Intake & Stage-Gate Skill (exemplar)

Objective: Transform a submitted pitch into a validated Incubator Brief and a recorded gate decision.

Inputs:

Field Required Description
raw_pitch Yes Unstructured description of the idea or problem
submitter_context No Role, team, or portfolio tag
constraints_hint No Compliance, budget, or timeline hints
idea_pool_snapshot_ref No Reference for deduplication

Procedure (checklist):

  1. Normalize — One-line hypothesis and problem sketch.
  2. Users & value — Provisional segments; flag needs_research where needed.
  3. Constraints — List constraints and assumptions; mark validated vs assumed.
  4. Unknowns — Top unknowns + smallest next experiment (timeboxed).
  5. Deduplication — If duplicate suspected, emit IncubatorDuplicateSuspected per policy.
  6. Gate — continue experiment / park / kill / promote-ready with rationale.
  7. Assemble — Markdown + JSON with trace_id, activation_mode, timestamps.
  8. Validate — Self-check rationale and promotion rules.
  9. Emit — IncubatorStageGateCompleted; IdeaPromotedToVision only after approval policy.

Anti-patterns:

Anti-pattern Why it fails
Skipping rationale on kill/park Breaks audit loops
Emitting VisionDocumentCreated from Incubator Vision scope is Vision Architect only
Unbounded cron fan-out Noise and cost
Treating Incubator Brief as Vision Document Wrong contract for downstream planning agents

🏗️ Visual: ConnectSoft Incubator Agent Internal Process Flow

flowchart TD
    A[Activation] --> B[Context load]
    B --> C{Mode?}
    C -->|on_demand| D[Intake & Stage-Gate Skill]
    C -->|scheduled| E[Signal synthesis + gate]
    C -->|event| F[Tagged run same as D/E]
    D --> G[Assemble artifacts]
    E --> G
    F --> G
    G --> H[Self-validation]
    H -->|Pass| I[Emit events]
    H -->|Fail| J[Retry / correction]
    J --> H
    I --> K[Observability]
    H -->|Escalate| L[Human review]
Hold "Alt" / "Option" to enable pan & zoom

🛠️ Key Principles in Process Flow

Principle How applied
Modularity Skills swap per activation mode without changing core contracts
Recoverability Retries for validation; explicit escalation to humans
Observability-first Every run has incubator_run_id and mode tags
Policy-bound autonomy Cron and auto-ideas never bypass configured caps and review rules

📣 Special Callouts

Tip

Short-term memory holds the in-progress brief and candidate batch during a single run.

Warning

Promotion to Vision Architect must never bypass approval policy or handoff checklist completeness.

Info

Draft-only cron output is the default recommendation for high-risk or regulated portfolios.

🛠️ System Prompt (Initialization)

ConnectSoft System Prompt: ConnectSoft Incubator Agent

You are the **ConnectSoft Incubator Agent** in the **ConnectSoft AI Software Factory**.

Your mission is to **explore, normalize, and stage-gate** ideas—optionally **propose candidate ideas** from allowlisted signals on a schedule—without producing a **Vision Document**.

You must:

- Operate according to **activation_mode** and **policy** (cron frequency, token budgets, deduplication, human review).
- Produce **Incubator Briefs** and **gate records** with **mandatory rationale** for park, kill, and promote-ready outcomes.
- Emit **`IdeaPromotedToVision`** only when promotion policy is satisfied; never emit **`VisionDocumentCreated`**.
- Flag **duplicates**, **low confidence**, and **sensitive domains** per configuration.
- Log and trace all steps for observability.

You must not:

- Replace the **Vision Architect**, **Product Manager**, **Product Owner**, or **Business Analyst** roles.
- Bypass **allowlists** on scheduled runs or exceed **quota**.

Your outputs must be machine-consumable and aligned with ConnectSoft factory event and artifact standards.

🧠 Memory Management

Memory type Purpose Storage mechanism
Short-term In-progress brief, batch of candidates, conversation for clarification Session / context window
Long-term Completed briefs, embeddings for deduplication and “related ideas” Artifact store + optional vector index

Short-term memory behavior

  • Retains the working brief and validation state between skill calls within one run.
  • Supports multi-turn clarification for ambiguous pitches.

Long-term memory behavior

  • Persists finalized briefs and candidate records with trace_id and activation_mode.
  • Enables similarity search before IncubatorCandidateIdeasPublished.
flowchart TD
    In["Inputs / signals"] --> STM["Short-term memory"]
    STM --> Skills["Skill execution"]
    Skills --> Draft["Brief / candidates"]
    Draft -->|Persist| LTM["Long-term / idea pool"]
    Draft -->|Emit| Bus["Event bus"]
Hold "Alt" / "Option" to enable pan & zoom

📣 Key Constraints

Info

Flush or partition short-term context after each incubator_run_id to avoid cross-run leakage.

Warning

Long-term embeddings and artifacts must respect multi-tenant isolation and data classification (e.g. no PHI in incubator artifacts when policy forbids it).

Tip

Use trace_id as the primary correlation key across logs, events, and storage paths.

✅ Validation Logic

Validation step Description
Structural Mandatory sections present for the active mode (brief fields or batch record shape).
Rationale present Every park/kill/promote-ready has non-empty rationale.
Policy compliance Cron within caps; allowlists respected; promotion rules satisfied.
Handoff checklist For promote-ready, Vision Architect prerequisites listed (problem, users, success signal).
Format Markdown and JSON parseable; metadata complete (trace_id, activation_mode, timestamps).
Confidence handling Below threshold triggers review or draft-only per policy—not silent publish.

🧩 Self-Validation Skill Chain

1. Structure Validator →
2. Rationale & policy Validator →
3. Deduplication check (if configured) →
4. Promotion rules Validator →
5. Final sanity check

Each step passes, fails with hints for auto-correction, or escalates.

🔁 Retry/Correction Flow

flowchart TD
    Gen[Generate brief / batch] --> Val[Validate]
    Val -->|Pass| Emit[Emit events]
    Val -->|Fail| Fix[Auto-correction]
    Fix --> Val2[Re-validate]
    Val2 -->|Pass| Emit
    Val2 -->|Fail| Human{Retries exhausted?}
    Human -->|Yes| Esc[Human intervention]
    Human -->|No| Fix
Hold "Alt" / "Option" to enable pan & zoom
Step Action
Initial validation After assembly, before emit.
Auto-correction Minor fixes (missing field, JSON lint).
Re-validation Repeat until pass or max retries.
Escalation Human review for repeated failure or sensitive outcomes.

🚦 Retry Policies

Scenario Auto-correct? Max retries Human intervention?
Missing mandatory brief section ✅ 2 ✅ if still failing
Missing gate rationale ✅ 1 ✅
Broken JSON ✅ (lint) 2 ✅
Policy violation (e.g. over cap) 🚫 0 ✅
Low confidence 🚫 0 ✅ per review policy

📣 Special Handling

Info

Ambiguity in a pitch may yield a clarification request to humans instead of a weak gate decision.

Warning

Do not emit IdeaPromotedToVision if the handoff checklist is incomplete or human approval is required but not recorded.

Tip

Log every retry and escalation for audit and tuning of autonomy.

📑 Correction Example (Auto-Fix)

Problem: Gate outcome is park but rationale field is empty.

Auto-fix: Infer short rationale from problem sketch and unknowns; if still empty, fail validation and retry once with expanded template.

🏛️ Diagram: Validation and Correction Lifecycle

flowchart TD
    O[Generated output] --> S[Structural validation]
    S --> R[Rationale / policy]
    R --> P[Promotion rules]
    P -->|All pass| F[Finalize & emit]
    P -->|Fail| C[Correction]
    C --> S
Hold "Alt" / "Option" to enable pan & zoom

🔗 Agent Communication Overview

The ConnectSoft Incubator Agent collaborates via event-driven emission, shared artifact storage, and orchestration policy. It is not a drop-in replacement for Vision Architect or product planning agents.

📡 Direct Collaboration Targets

Target Purpose Interaction mode
Vision Architect Agent Consume promotion handoff to build Vision Document Event IdeaPromotedToVision + artifact URI
Orchestration layer Schedules, policies, quotas Config + control plane
Humans Gate approval, promotion approval, cron draft review Portal / notifications
Product Manager / PO / BA Typically after Vision Document; optional exceptions by process Out of band / explicit workflow
Knowledge Management Agent (optional) Archive briefs for search Artifact + embedding

🧩 Collaboration Interfaces Design

Type Mechanism Notes
Event emission Versioned JSON payloads on event bus Idempotent consumers
Shared artifact storage Incubator Brief + idea pool records URIs in event payloads
Scheduler Cron / event triggers Tenant-scoped
Optional vector index Embeddings for deduplication Isolated per tenant

📜 Example: IncubatorStageGateCompleted Event Schema

{
  "eventType": "IncubatorStageGateCompleted",
  "eventTime": "2025-04-28T10:05:00Z",
  "data": {
    "trace_id": "inc-20250428-abc",
    "activation_mode": "on_demand",
    "gate_outcome": "continue_experiment",
    "brief_uri": "https://storage.example/inc/inc-20250428-abc.md",
    "confidence_score": 0.78
  },
  "metadataVersion": "1.0"
}

📜 Example: IdeaPromotedToVision Event Schema

{
  "eventType": "IdeaPromotedToVision",
  "eventTime": "2025-04-28T10:10:00Z",
  "data": {
    "trace_id": "inc-20250428-abc",
    "incubator_brief_uri": "https://storage.example/inc/inc-20250428-abc.md",
    "handoff_checklist_complete": true,
    "approved_by": "policy:auto|human:user-123"
  },
  "metadataVersion": "1.0"
}

🛠️ Example Collaboration Flow

sequenceDiagram
    participant Incubator as ConnectSoft Incubator Agent
    participant Bus as Event Bus
    participant VA as Vision Architect Agent
    participant Human as Human reviewer

    Incubator->>Bus: IncubatorStageGateCompleted
    alt promote-ready + approved
        Incubator->>Bus: IdeaPromotedToVision
        Bus-->>VA: Handoff for Vision Document
    else draft or review required
        Incubator->>Human: Review queue
    end
Hold "Alt" / "Option" to enable pan & zoom

📣 Best Practices for Collaboration

Tip

Always attach trace_id, project_id, and activation_mode to events and artifacts.

Warning

Vision Architect must not receive promotion events for incomplete handoff checklists.

Info

Consumers of Incubator events should be idempotent (at-least-once delivery).

📑 Collaboration Responsibilities by Interface

Interface Incubator responsibility
Event bus Emit only after validation; correct ordering for gate then promotion
Artifact store Version briefs and pool updates; enforce retention policy
Scheduler Respect caps; tag runs with schedule_id
Human review Surface low-confidence and draft cron batches per policy

📣 Events emitted and consumed

Emitted (examples)

Event When
ExplorationStarted New intake or scheduled run started
IncubatorStageGateCompleted Brief + gate outcome persisted
IdeaPromotedToVision Handoff approved
IdeaParkedOrClosed Park or kill with rationale
IncubatorScheduledRunStarted Cron/batch run began
IncubatorCandidateIdeasPublished Batch candidates written (may be draft-only)
IncubatorDuplicateSuspected Duplicate detection

Consumed (examples)

Event Use
Policy-mapped platform or factory events Trigger scoped Incubator runs when configured

📊 Observability Hooks

Type Description Tooling
Structured logging Run start/end, mode, gate outcomes, emits Serilog (JSON)
Distributed tracing Full path across skills and validation OpenTelemetry
Metrics Counters, histograms for runs, promotions, failures Prometheus-compatible
Audit Event emission log correlated with trace_id Internal audit store

📜 Key Logs Captured

Log entry Example fields
Run start incubator_run_id, activation_mode, schedule_id
Brief generated trace_id, gate_outcome, confidence_score
Validation validation_status, errors
Retry retry_number, reason
Event emitted event_type, payload_summary
Human escalation reason, missing_fields

📈 Key Metrics Exposed

Metric Description
incubator_runs_total Runs by activation_mode
incubator_stage_gate_total By gate_outcome
incubator_promotions_total IdeaPromotedToVision count
incubator_validation_failures_total Validation failures
incubator_retry_attempts_total Retries
incubator_human_interventions_total Escalations
incubator_run_duration_seconds Latency histogram
incubator_scheduled_run_cost_tokens Optional token burn for cron

Agent health (interpretation):

Metric Meaning
Time to first brief On-demand latency
Promotion rate Tune noise vs value
Scheduled run cost SLO for cron jobs
Duplicate rate Deduplication quality

🏗️ Visual: Observability Integration Flow

flowchart TD
    Start[Run start] --> L1[Log / trace]
    Skills[Skills] --> L2[Log / span]
    Val[Validation] --> L3[Log / metrics]
    Emit[Event emit] --> L4[Audit log]
    L1 & L2 & L3 & L4 --> Stack[Observability stack]
Hold "Alt" / "Option" to enable pan & zoom

🤖 Human Intervention Points

Situation Intervention
Validation fails after retries Human completes or rejects brief
Low confidence Review before publish or promotion
Cron draft-only policy Human approves candidate batch
Sensitive domain Mandatory approval before promotion
Ambiguous pitch Clarification session

🧩 How Human Intervention Works

flowchart TD
    Out[Output ready] --> V[Validation]
    V -->|OK| E[Emit events]
    V -->|Review required| N[Notify human]
    N --> P[Review portal]
    P -->|Approve| E
    P -->|Edit| V
    P -->|Reject| X[Close / park with rationale]
Hold "Alt" / "Option" to enable pan & zoom

Mechanisms: notifications, review portal, approve / edit / reject with logged reasons.

📣 Best Practices

Tip

Log reviewer id, action, and rationale for every human intervention.

Warning

Configure default autonomy per portfolio: autonomous vs review-heavy.

Info

Intervention metrics inform policy tuning and prompt improvements.

🏗️ Full Agent Blueprint Overview

The ConnectSoft Incubator Agent is a Vision and Product Planning cluster agent focused on exploration, optional promotion, and scheduled ideation. It does not own the Vision Document lifecycle.

📚 Complete Logical Responsibilities Map

flowchart TD
    A1[Inputs: pitch / signals / policy] --> A2[ConnectSoft Incubator Agent]
    A2 --> B1[Intake & Stage-Gate Skill]
    A2 --> B2[Signal synthesis]
    A2 --> B3[Dormancy scan]
    B1 & B2 & B3 --> C1[Assemble brief / pool]
    C1 --> D1[Validation chain]
    D1 -->|Pass| E1[Emit Incubator events]
    D1 -->|Fail| F1[Retry / human]
    E1 -->|optional| G1[IdeaPromotedToVision]
    G1 --> H1[Vision Architect Agent]
Hold "Alt" / "Option" to enable pan & zoom

📈 Technical Stack Blueprint

flowchart TD
    SK[Semantic Kernel] --> LLM[LLM]
    SK --> Mem[Short-term context]
    SK --> Art[Artifact store]
    SK --> Vec[(Vector optional)]
    SK --> Bus[Event bus]
    Sch[Scheduler] --> SK
    SK --> OT[OpenTelemetry]
Hold "Alt" / "Option" to enable pan & zoom

🧩 Component and Subsystem Diagram

flowchart LR
    subgraph ConnectSoft Incubator Agent
        In[Input] --> Pre[Preprocess / policy]
        Pre --> Chain[Skill chain]
        Chain --> Val[Validation]
        Val -->|Pass| Out[Event + artifact]
        Val -->|Fail| Retry[Retry / human]
    end
    Out --> Bus[Event bus]
    Out --> Store[Storage]
Hold "Alt" / "Option" to enable pan & zoom

🛡️ Responsibility Layer Mapping

Layer Responsibilities
Activation Resolve mode, load policy and snapshots
Skill execution Intake, synthesis, dormancy
Validation & correction Structure, rationale, promotion rules
Artifact & pool Version briefs and candidates
Events Emit validated payloads only
Observability Logs, traces, metrics
Human hooks Review queues and escalations

🧠 Key Highlights

✅ Multi-modal: On-demand, cron, event-driven, standalone.
✅ Optional handoff to Vision Architect via IdeaPromotedToVision only.
✅ Exemplar skill documented for factory-wide skill patterns.
✅ Policy-bound scheduled ideation with deduplication and review.
✅ Observability-first runs with clear correlation IDs.

🧩 ConnectSoft Incubator Agent in the Entire Factory Flow (Macro View)

flowchart TD
    subgraph Optional["Optional exploration"]
        Inc[ConnectSoft Incubator Agent] -.->|IdeaPromotedToVision| VA[Vision Architect Agent]
    end
    VA --> PM[Product Manager Agent]
    VA --> BA[Business Analyst Agent]
    Inc --> Pool[Idea pool / parked]
Hold "Alt" / "Option" to enable pan & zoom

📚 Conclusion for ConnectSoft Incubator Agent Spec

The ConnectSoft Incubator Agent provides a governed exploration lane and proactive ideation capability inside the ConnectSoft AI Software Factory. It keeps optionality and cost control at the front of innovation while preserving the Vision Architect as the authority for full vision artifacts.

Without lightweight exploration, teams over-invest in formal vision too early; the Incubator balances speed, auditability, and optional promotion.

🚀 Future Extensions

  • Deeper integration with experiment result ingestion (auto-update gate from outcomes).
  • Portfolio scoring models for candidate ranking on cron runs.
  • Cross-tenant pattern libraries (anonymized) for similarity search.
  • Formal SLA templates per industry for human review timing.