📍 Growth Strategist Agent¶

Purpose¶

The Growth Strategist Agent is a high-level, analytical, and generative agent within the ConnectSoft AI Software Factory that is responsible for synthesizing marketing insights, user behavior data, product adoption signals, and campaign results into actionable growth strategy blueprints.

Its mission is to design, prioritize, and adapt product-led and data-driven growth loops that span across the customer journey — from awareness to monetization — and across product editions and verticals.

It doesn't just suggest experiments — it models systemic, compound growth across the factory-generated SaaS portfolio.

🧠 Core Role in the Factory¶

The Growth Strategist Agent is the decision optimizer of the Growth, Marketing & Customer Success cluster. It closes the loop from campaign execution and user engagement back to platform-wide learning and strategic growth modeling.

🧩 Position in the Growth, Marketing & Customer Success Cluster¶

Layer	Cluster	Description
🧠 Strategic Planner	Growth, Marketing & Customer Success	Translates GTM and adoption data into high-level growth directives
🔁 Feedback Integrator	Connects campaign results to product improvement and onboarding changes
📡 Signal Amplifier	Amplifies validated experiments and successful loops across editions

flowchart TD
    MSA[Marketing Specialist Agent] --> GSA[Growth Strategist Agent]
    CSA[Customer Success Agent] --> GSA
    ABT[A/B Testing Agent] --> GSA
    OBS[Observability Agent] --> GSA
    GSA --> EXP[Experimentation Agent]
    GSA --> PLG[Onboarding Flow Tuner]
    GSA --> PM[Product Manager Agent]

Hold "Alt" / "Option" to enable pan & zoom

🚀 Strategic Contribution¶

Dimension	Contribution
📈 Growth Architecture	Defines and codifies systemic SaaS growth strategies
🔁 Funnel Optimization	Identifies weakest conversion stages and aligns experiments
📊 KPI Mapping	Maps product features to adoption, revenue, and retention KPIs
🧪 Experiment Direction	Proposes and prioritizes growth experiments across channels and editions
🧠 Learning Feedback Loop	Synthesizes results from campaign, onboarding, and customer success outputs

🔄 Triggering Events¶

Event Trigger	Description
`campaign_outcome_ready`	Receives CTR/open/conversion performance data from marketing stack
`feature_usage_analyzed`	Reacts to feature-level telemetry and usage insights
`onboarding_path_tested`	Ingests multi-variant onboarding performance signals
`growth_loop_configured`	Expands/validates a designed viral or retention loop across editions

✅ Summary¶

The Growth Strategist Agent is the strategic AI operator ensuring every campaign, onboarding flow, and customer touchpoint feeds into a smarter, optimized, and systemically growing SaaS product.

It answers:

“Where is the next 10x opportunity?”
“Which stage of our funnel is leaking most?”
“Which persona is not activating as expected — and why?”

Without this agent, SaaS growth is reactive and fragmented. With it, growth becomes an intentional, AI-optimized engine.

📦 Responsibilities and Deliverables¶

The Growth Strategist Agent is responsible for transforming fragmented data and tactical insights into cohesive, prioritized, and edition-aware growth strategies. It acts as a strategist, analyst, and orchestrator — feeding actionable blueprints into downstream agents and systems.

🧰 Key Responsibilities¶

Responsibility	Description
📈 Growth Model Definition	Create growth loop blueprints (e.g., virality, referral, PLG) for product adoption and scaling
📊 Funnel Diagnosis and Optimization	Analyze bottlenecks across awareness → onboarding → retention funnel stages
🧪 Experiment Portfolio Prioritization	Propose ranked A/B and multivariate tests to resolve strategic uncertainties
🧭 KPI-to-Feature Mapping	Link product features to measurable business outcomes (e.g., feature → activation rate)
🔁 Adoption Loop Feedback	Ingest onboarding, campaign, and customer success results to refine growth hypotheses
🌍 Edition-Aware Strategy Customization	Tailor strategies for Lite, Pro, and Enterprise product editions
🪄 PLG (Product-Led Growth) Activation Design	Suggest user onboarding improvements that drive self-serve conversion
🧠 Compounding Knowledge Memory	Learn from prior strategies to avoid redundant growth paths and optimize ROI
📢 Strategy-to-Experiment Delegation	Emit structured tasks and prompts to A/B Testing and Experimentation Agents

📤 Deliverables¶

Deliverable Type	Description
🗺️ Growth Strategy Blueprint	A structured YAML or Markdown plan describing target metrics, hypotheses, loop design
📊 Funnel Heatmap + Action Plan	Visual and structured summary of current funnel drop-off points + fixes
🧪 Test Prioritization Sheet	Ranked list of experiments to execute (w/ KPIs, effort, risk scores)
📈 Edition-Specific Strategy Matrix	Matrix of what works best per edition and what’s underperforming
📚 Strategy Memory Index	Historical store of validated strategies, test outcomes, and improvement deltas

🧩 Example Blueprint Output (YAML)¶

growth_strategy_id: gs-lite-202406
persona_id: startup_ops_manager
edition: lite
primary_kpi: activation_rate
hypothesis: "Onboarding automation boosts activation by 20%"
recommended_loop:
  type: onboarding_nudges
  components:
    - contextual CTA
    - email nudge (day 1, 3, 7)
    - in-product checklist
experiments:
  - test_id: abt-cta-intro-vs-demo
    objective: Increase initial CTA engagement
    kpi: clickthrough_rate
    variants: 2
priority: high

✅ Summary¶

The Growth Strategist Agent ensures strategy is never ad hoc — it’s generated, tested, learned from, and constantly refined.

It delivers:

🚀 Blueprints for product-led and campaign-based growth
📊 Visual funnel analysis + next best actions
🧪 Experiment maps and test directives
🧠 Persistent knowledge compounding

It is the agent that connects intelligence to growth execution — and fuels scalable SaaS expansion.

⚡ Trigger Events and Activation Points¶

The Growth Strategist Agent is not always active — it is event-driven, activating at key inflection points in the SaaS lifecycle where growth reevaluation, adaptation, or strategic planning is required. It reacts to upstream signals, milestone completions, and performance feedback loops from across the Factory.

🔁 Core Activation Triggers¶

Event Name	Description
`campaign_outcome_ready`	Triggered when performance data (CTR, conversions) from Marketing Specialist Agent is finalized
`onboarding_flow_tested`	Triggered after a completed onboarding A/B test with new telemetry
`feature_usage_analyzed`	Occurs after usage tracking reveals low adoption or unexpected user patterns
`edition_launch_ready`	Initiates edition-specific growth strategy for upcoming launches
`persona_growth_stalled`	Triggered when growth among a specific persona cohort drops below threshold
`customer_churn_spike_detected`	Fired by Customer Success Agent or Observability Agent on churn anomaly
`product_roadmap_shifted`	Triggered by Product Manager Agent on significant roadmap changes
`new_market_opened`	Fired when geographic or vertical localization requires growth redesign

🧠 Triggering Agents and Systems¶

flowchart TD
    MSA[Marketing Specialist Agent] -->|campaign_outcome_ready| GSA[Growth Strategist Agent]
    CSA[Customer Success Agent] -->|churn_data| GSA
    ABT[A/B Testing Agent] -->|onboarding_test_result| GSA
    OBS[Observability Agent] -->|usage anomaly| GSA
    PM[Product Manager Agent] -->|roadmap_shifted| GSA
    LOC[Localization Module] -->|market_expansion| GSA

Hold "Alt" / "Option" to enable pan & zoom

⏱ Trigger Frequency and Schedule¶

Mode	Description
📥 Event-driven	Primary mode. Activates via signal, not schedule
🕒 Time-based Check	(Optional) Weekly or monthly review to detect silent stalling or missed patterns
🚨 Anomaly-driven	Activated by spike or threshold detection (drop in engagement, sudden churn)

💡 Trigger Payload Example¶

{
  "trigger": "feature_usage_analyzed",
  "feature_id": "smart_scheduling",
  "edition": "pro",
  "persona_id": "clinic_admin",
  "observation": "Usage dropped 35% after onboarding flow change"
}

This triggers the Growth Strategist Agent to analyze drop, identify funnel regression, and propose mitigations.

✅ Summary¶

The Growth Strategist Agent is designed for adaptive activation — listening, responding, and acting only when strategic redirection is required.

It doesn’t run blindly — it wakes up when the business needs it most.

📥 Inputs¶

The Growth Strategist Agent consumes a diverse set of structured and semi-structured inputs — from telemetry signals and campaign outcomes to persona data, onboarding flows, and product editions. These inputs enable it to form a data-informed and persona-aligned growth strategy.

🧩 Structured Input Categories¶

Input Type	Source Agent or System	Description
📊 Campaign Performance	Marketing Specialist Agent	CTR, open rates, conversion metrics, drop-off points
🧪 A/B Test Results	A/B Testing Agent	Variant results from landing pages, emails, onboarding, feature adoption
🧭 Feature Usage Insights	Observability Agent	Time-in-app, feature completion rates, ignored features, dropoff sessions
🧠 Persona Definitions	Persona Builder Agent	Pain points, behavioral triggers, emotional tones, friction sources
🧩 Edition Metadata	Product Owner Agent	Feature set per edition, intended audience, onboarding constraints
📈 Churn and Retention Logs	Customer Success Agent	Who churned, when, why (if known), retention stage data
🛠 Product Roadmap Shifts	Product Manager Agent	Roadmap changes that alter funnel dynamics, value propositions
🌐 Localization Signals	Localization Agent or Locale Modules	New regions, cultural insights, content mismatches

📄 Input Format (YAML Example)¶

persona_id: startup_ops_manager
edition: lite
primary_kpi: activation_rate
campaign_summary:
  ctr: 3.4%
  conversion_rate: 1.2%
  active_variant: "lite-email-v2b"
a_b_tests:
  - test_id: abt-onboarding-cta-vs-checklist
    result: variant_b
    uplift: 12%
feature_usage:
  feature_id: task_automation
  usage_delta: -35%
  note: "Significant drop post-onboarding change"
retention:
  30_day_retention: 41%
  churn_reasons: ["too complex", "missing integrations"]
roadmap_updates:
  new_feature: smart_calendar
  rollout_date: 2024-07-01
  expected_value: "reduce friction in appointment flow"

🎯 Key Required Fields¶

Field	Purpose
`persona_id`	Allows targeting and empathy modeling
`edition`	Strategy must adapt to capabilities/limitations of each edition
`feature_usage`	Identifies adoption gaps and drop points
`a_b_tests`	Feeds decision making with experiment results
`campaign_summary`	Indicates effectiveness of current GTM efforts
`retention/churn_data`	Points to problems in value delivery or fit

📦 Input Memory Tags¶

All inputs are embedded and tagged with:

trace_id – for observability and rollback
input_source – to identify who provided what
timestamp – for recency-weighted reasoning
segment_scope – persona, edition, feature, funnel stage

✅ Summary¶

The Growth Strategist Agent consumes a 360° view of product and user data — everything it needs to turn fragmented signals into cohesive growth actions.

Garbage in, garbage out — this agent is only as powerful as the truth it’s fed.

📤 Outputs¶

The Growth Strategist Agent produces structured, traceable, and actionable outputs that direct and coordinate growth actions across the ConnectSoft AI Software Factory. These outputs are designed to be consumed by downstream agents — such as A/B Testing Agent, Marketing Specialist Agent, Onboarding Flow Tuner — or directly injected into observability and product planning systems.

🎯 Output Objectives¶

Each output is engineered to:

Operationalize insights into experiments or strategic changes
Provide a multi-edition, persona-aware plan of action
Inform and activate other agents and modules automatically
Be version-controlled, memory-tracked, and score-aware

📦 Key Output Types¶

Output Type	Description
📈 Growth Strategy Blueprint	YAML or Markdown document outlining growth hypotheses, loops, KPIs, and edition-specific plans
🧪 Experiment Portfolio Sheet	Structured list of prioritized experiments with KPIs, audience segments, and test specs
📊 Funnel Action Report	Diagnosis of where the funnel is leaking + recommendations to address it
🗂 Edition Strategy Matrix	Mapping of persona/edition to specific growth tactics and adjustments
📎 Memory Index Entry	Log of all generated strategies and test recommendations for future reuse and learning

🧩 Output Format Example (Growth Blueprint – YAML)¶

growth_strategy_id: gs-lite-202407
edition: lite
persona_id: startup_ops_manager
primary_kpi: activation_rate
growth_loop:
  type: onboarding_cta_loop
  components:
    - CTA on landing
    - onboarding checklist
    - email reactivation (day 3, 7)
experiments:
  - test_id: abt-lite-checklist-vs-progressbar
    hypothesis: Visual progress indicator increases activation by 15%
    variants: 2
    priority: high
    assigned_agent: ab_testing_agent
strategy_notes:
  - Remove “Pro” tier references from Lite onboarding
  - Highlight immediate value: “Save 5+ hours per week”
  - Add “personal setup assistant” modal experiment

🧾 Additional Output Fields¶

Field	Purpose
`strategy_score`	Internal confidence/priority score for agent-generated recommendation
`trace_id`	Ties output to input data and execution trigger
`generated_by`	Which agent instance and model version
`review_required`	Flag to denote whether human validation is needed
`reusable_template`	Whether this strategy is reusable for other editions or personas

🔄 Output Consumption¶

Consumed By	Purpose
A/B Testing Agent	To run the proposed experiments
Customer Success Agent	To adapt onboarding and engagement sequences
Product Manager Agent	To consider roadmap reprioritization
Observability Agent	To monitor activation of strategy and signal drift

✅ Summary¶

Outputs from the Growth Strategist Agent are blueprints for acceleration — they tell the system what to try, who to target, and how success should look.

They are not static reports — they are living growth instructions, ready for execution.

🧠 Knowledge Base¶

The Growth Strategist Agent operates from a robust foundation of built-in and continuously enriched knowledge, covering growth frameworks, SaaS metrics, behavioral psychology, persona behavior models, and edition-specific GTM playbooks.

Its knowledge base allows it to reason like a growth expert, but with AI-powered scale, memory, and adaptation.

📚 Preloaded Strategic Knowledge¶

Knowledge Domain	Description
📈 SaaS Growth Frameworks	AARRR, RARRA, Flywheel models, PLG (Product-Led Growth), Viral Loops
🧪 Experimentation Playbooks	Common hypotheses, test structures, statistical thresholds
📊 Funnel Metrics Models	Awareness, Activation, Retention, Referral, Revenue stages
🧩 Edition-Aware Strategy	How Lite, Pro, Enterprise editions differ in value prop, CAC, retention logic
🧠 Behavioral Trigger Models	Based on persona’s fears, aspirations, roles, and habits
🛠️ B2B SaaS Benchmarks	Baseline conversion/activation benchmarks per segment/industry

🧩 Dynamic Knowledge (Updated During Execution)¶

Source	Type of Knowledge
Observability Agent	Feature usage patterns, time-in-app, dropoff signals
A/B Testing Agent	Variant winners, KPI uplifts
Customer Success Agent	Churn reasons, CSAT/NPS trends
Marketing Specialist Agent	Campaign CTR/ROI trends per persona and tone
Memory Store (Vector DB + Logs)	Strategy outcomes, effective CTA patterns, failure logs

🧬 Semantic Memory Embeddings¶

The agent stores and retrieves:

Past growth loop blueprints
Failed strategies (to avoid repetition)
High-performing call-to-actions
Persona-strategy mappings from similar profiles

This memory supports semantic search and adaptation to new but analogous situations.

🧠 Ontology and Strategy Graph¶

It maintains an internal growth ontology linking:

graph TD
    Activation -->|boosted by| OnboardingChecklist
    OnboardingChecklist -->|tested in| TestABX
    TestABX -->|produced| +12% activation
    Activation -->|leads to| Retention
    Retention -->|drops with| LowFeatureAdoption
    LowFeatureAdoption -->|detected by| ObservabilityAgent

Hold "Alt" / "Option" to enable pan & zoom

This internal knowledge graph grows with every input, experiment, and outcome.

🔁 Knowledge Update Policies¶

Type	Update Frequency	Notes
Static Frameworks	Manual or infrequent	Core principles (e.g. AARRR) are version-controlled
Memory Embeddings	Continuous	Updated after every strategy output or signal ingested
Test Results	On experiment close	Success/failure recorded, uplift scores tracked
Churn/Retention	Daily or trigger-based	Especially when unexpected drops occur

✅ Summary¶

The Growth Strategist Agent combines:

🧠 Strategic mental models (preloaded)
🧩 Personalized learning loops (agent memory)
📊 Real-time data feedback (telemetry)

It reasons like a top-tier growth consultant — but one that never forgets and always improves.

🔄 Process Flow¶

The Growth Strategist Agent follows a structured, multi-phase execution pipeline designed to ingest signals, diagnose bottlenecks, synthesize opportunities, and output strategic growth blueprints. This pipeline ensures deterministic reasoning with modular checkpoints for retries, memory updates, and downstream handoffs.

⚙️ High-Level Execution Phases¶

flowchart TD
    A[Start: Growth Trigger Received] --> B[Signal Intake]
    B --> C[Funnel Diagnosis]
    C --> D[Opportunity Synthesis]
    D --> E[Strategy Blueprint Generation]
    E --> F[Experiment Portfolio Prioritization]
    F --> G[Output Emission + Memory Indexing]

Hold "Alt" / "Option" to enable pan & zoom

🧩 Detailed Process Breakdown¶

Step	Name	Description
1	Signal Intake	Ingests input payloads: campaign data, feature usage, churn logs, test results, edition data
2	Funnel Diagnosis Engine	Maps awareness → activation → retention funnel and identifies performance leaks
3	Growth Opportunity Synthesis	Applies heuristics, memory recall, and prompt templating to hypothesize high-impact directions
4	Strategy Blueprint Generator	Constructs edition/persona-specific YAML growth plans with KPI targets, loops, and CTAs
5	Experiment Prioritizer	Generates ranked test ideas based on risk/reward, feasibility, impact, novelty
6	Output Emission	Pushes strategy to other agents (e.g., A/B Testing Agent) and logs everything into memory
7	Memory Update Hook	Indexes results, links outcome-to-hypothesis mappings, version tags, traceability data

🛠 Modular Subsystems¶

Subsystem	Role
🧠 Strategy Reasoner	Uses prompt templates + Semantic Kernel to explore growth hypotheses
📈 Metric Analyzer	Detects underperformance in funnel or feature metrics
🧪 Test Generator	Suggests testable growth hypotheses based on past wins/failures
📂 Trace Manager	Maintains full lineage of input→output→execution results

🕵️‍♂️ Decision Points¶

Condition	Action
Input is stale or conflicting	Re-validates via Observability or Customer Success agents
Hypothesis already tested recently	Retrieves past variant and result from memory
Conflicting outputs from multiple data sources	Prompts for human validation or defers until resolved

🔄 Iteration Capabilities¶

Can re-trigger itself if strategy fails (detected via Observability metrics or test failure)
Capable of multi-wave growth strategy planning (e.g., plan v1 → run test → observe → plan v2)

✅ Summary¶

The Growth Strategist Agent operates through a multi-phase, memory-augmented reasoning pipeline — converting data into growth strategy with:

🧠 Strategic thinking
🔁 Feedback awareness
📎 Traceable logic
🪄 AI-native autonomy

It is not a one-shot generator — it is a cyclical, evolving strategist embedded in the Factory.

🛠 Skills and Kernel Functions¶

The Growth Strategist Agent leverages a curated set of Semantic Kernel skills, embedded plugins, and functional planners to reason, prioritize, recall, and generate optimized growth strategies. These skills give it modularity, auditability, and composability across use cases.

🧠 Core Reasoning Skills¶

Skill Name	Purpose
`diagnose-funnel-leaks`	Analyze funnel metrics to detect major drop-off points
`map-feature-to-KPI`	Connect product features to measurable outcomes
`generate-growth-loop`	Create onboarding/retention/referral loops tailored to edition/persona
`summarize-churn-signals`	Synthesize churn/root-cause narratives from customer success input
`compare-variant-memory`	Retrieve and rank prior similar tests for decision guidance
`edition-strategy-template`	Load edition-aware default strategies to adapt and extend

📚 Memory-Aware Functions¶

Function	Description
`recall-successful-loop`	Retrieve high-performing growth loop for similar persona/edition
`detect-strategy-collision`	Avoid duplicating or conflicting previously failed strategies
`score-growth-opportunity`	Assign priority/confidence to a newly identified growth opportunity
`tag-and-index-strategy`	Store strategy metadata with traceability info (persona, edition, time, tags)

📤 Output Functions¶

Function	Description
`emit-growth-blueprint`	Output YAML document for downstream agents (experimentation, onboarding, etc.)
`emit-prioritized-tests`	Create experiment list with KPI mappings, hypothesis, and assignment
`notify-pm-agent`	Push funnel insights to Product Manager Agent when product-level change needed
`notify-customer-success`	Forward re-engagement hypotheses or CSAT-specific churn loops

📦 Plugin Examples¶

Plugin Type	Examples	Usage
📊 Observability	Ingest metrics, funnel charts, session data	Used in `diagnose-funnel-leaks`
📈 Analytics	Compare personas or editions performance trends	Supports `score-growth-opportunity`
🧪 A/B Results	Pull historical experiment data	Supports `compare-variant-memory`
🧬 Memory Vector DB	Access semantically similar blueprints	Used in `recall-successful-loop`

🧭 Skill Composition Example (Pseudocode)¶

var funnel = await Kernel.InvokeAsync("diagnose-funnel-leaks", input);
var loop = await Kernel.InvokeAsync("generate-growth-loop", funnel);
var testIdeas = await Kernel.InvokeAsync("score-growth-opportunity", loop);
await Kernel.InvokeAsync("emit-growth-blueprint", testIdeas);

✅ Summary¶

The Growth Strategist Agent behaves like a growth executive with a modular brain — powered by kernel functions that let it:

Think in funnels and loops
Recall success and avoid past mistakes
Suggest experiments with KPIs
Strategize by persona and edition

The agent is not a prompt shell — it is a skill-augmented growth operator.

🧪 Technologies Used¶

The Growth Strategist Agent is powered by a modern AI-first, modular technology stack designed for observability, interoperability, and composability. It builds on top of Semantic Kernel, leverages MCP orchestration, and operates with seamless access to ConnectSoft’s telemetry, memory, and event-driven systems.

🧠 Core AI and Planning Stack¶

Technology	Role in Agent Functionality
Semantic Kernel	Orchestrates planner execution, memory recall, skill chaining
OpenAI (GPT-4o / GPT-4)	Executes reasoning-heavy prompts and creative strategy synthesis
ConnectSoft Prompt Templates	Domain-specific structured prompt layer for consistency and extensibility

🧩 Memory and Reasoning Context¶

Component	Functionality
Vector Memory Store (Qdrant)	Stores and retrieves semantic memories of past strategies and tests
Short-Term Memory Window	Context window injection via Semantic Kernel (for active dialogue)
Trace-Linked Memory Indexing	Attaches inputs/outputs/trace IDs to all decisions for full traceability

🧰 Integration and Agent Collaboration¶

Tool/System	Role
MCP Servers	Enables inter-agent routing and API surface for emitting tasks
Azure Event Grid	Receives trigger signals (e.g. `feature_usage_analyzed`)
Azure Application Insights	Telemetry ingestion, funnel analysis, observability hooks
Azure Blob + Table Storage	Archive of strategy blueprints, experiment plans, and test logs

🧪 Experiment Feedback Loop¶

Integration	Purpose
A/B Testing Agent	Consumes experiments and sends back results
Observability Agent	Emits updated metrics, signals regressions/anomalies
Customer Success Agent	Provides churn trends, user complaints, CSAT scores

🛠 Developer Utilities¶

Utility	Purpose
Semantic Kernel Planner Plugin	Powers conditional skill execution trees
Prompt Debug Console	View intermediate reasoning steps and score confidence
Growth Strategy Simulator	Run and visualize hypothetical funnel flows (local agent mode)

📂 File and Output Formats¶

Format	Usage
`.yaml`	Growth blueprints, experiment portfolios
`.md`	Strategy reports for human review
`.json`	System-level event payloads, metrics logs

✅ Summary¶

This agent is built on the connective tissue of AI-native growth planning:

🧠 Semantic Kernel + OpenAI for smart reasoning
🔄 Event-driven signals from telemetry
🧩 Composable skills and memory graphs
🔗 Multi-agent orchestration via MCP + Azure

It's not just smart — it’s deeply integrated, self-learning, and platform-native.

🧾 System Prompt¶

The System Prompt is the foundational instruction injected into the Growth Strategist Agent at instantiation. It encodes its core identity, reasoning posture, expected behavior, and strategic intent, and ensures the agent behaves like a high-level growth advisor with memory and telemetry awareness.

🧠 Prompt Design Goals¶

Reinforce strategic, funnel-aware reasoning
Focus on multi-edition SaaS growth modeling
Guide the agent to propose testable, ROI-aligned ideas
Align output structure with ConnectSoft growth blueprint format
Make decisions traceable, reusable, and explainable

📜 System Prompt (Canonical Version)¶

You are the Growth Strategist Agent in the ConnectSoft AI Software Factory.

Your primary objective is to analyze product, marketing, and customer signals to generate data-informed, high-leverage growth strategies that optimize activation, retention, and monetization.

You operate after a product edition is defined and early telemetry is available.

You specialize in:
- Funnel diagnosis: Awareness → Activation → Retention → Referral → Revenue
- Product-led growth loops and onboarding optimization
- Multi-edition SaaS strategy generation (Lite, Pro, Enterprise)
- Testable hypothesis generation and prioritization
- Collaborating with agents like A/B Testing Agent, Observability Agent, and Marketing Specialist Agent

Your outputs include:
- Structured growth blueprints in YAML format
- Ranked experiment ideas with KPIs
- Persona-specific onboarding and messaging recommendations
- Strategy trace metadata (persona, edition, feature, timestamp)

You remember all past strategies, outcomes, and experiments.
You avoid suggesting duplicate or failed strategies.

You must reason step-by-step before recommending a loop or experiment.
Always link growth hypotheses to measurable KPIs.

Use cautious language for unvalidated assumptions.
Never suggest strategy changes without mapping to actual funnel observations.

When in doubt, recommend a hypothesis test.

🧩 Embedded Behavior via Prompt¶

Behavior Target	Prompt Strategy
Strategic Tone	"Step-by-step reasoning", "measurable KPIs", "growth hypotheses"
Edition-Awareness	"Multi-edition SaaS strategy generation"
Avoid Repetition	"Avoid suggesting duplicate or failed strategies"
Collaboration Readiness	"Collaborating with agents..."
Output Format Control	"Structured growth blueprints in YAML format"

✅ Summary¶

The Growth Strategist Agent is bootstrapped with clarity and depth — not just a task instruction, but an embedded philosophy:

Think like a strategist. Act like a funnel optimizer. Output like a system. Learn like a compounding AI.

✉️ Input Prompt Template¶

The Input Prompt Template is a dynamic semantic scaffold used to translate incoming structured signals into a reasoning-ready format. It ensures that all funnel insights, telemetry signals, edition metadata, and user behavior patterns are contextualized for the Growth Strategist Agent’s reasoning engine.

This prompt is injected into the Semantic Kernel pipeline after signal intake and before strategy generation.

🎯 Template Objectives¶

Normalize inputs into agent-readable context
Emphasize persona and edition alignment
Prime the agent for funnel-aware diagnostics
Encourage hypothesis generation and output structuring

📜 Canonical Input Prompt Template¶

You are the Growth Strategist Agent.

Below is a snapshot of current growth signals for a specific edition, persona, and product context. Your task is to analyze this input, identify the main growth bottleneck(s), and propose a testable, data-informed growth strategy.

Input context:

- Persona: {{persona_id}} ({{persona_description}})
- Edition: {{edition_id}} ({{edition_notes}})
- Primary KPI to improve: {{kpi}} (e.g., activation_rate, retention_30d, referral_rate)
- Funnel Observations:
  - Awareness: {{funnel.awareness}}
  - Activation: {{funnel.activation}}
  - Retention: {{funnel.retention}}
  - Referral: {{funnel.referral}}
  - Revenue: {{funnel.revenue}}
- Feature usage signals:
  {{#each feature_usage}}
    - {{this.feature_id}}: {{this.trend}} ({{this.notes}})
  {{/each}}
- A/B Test Results:
  {{#each ab_tests}}
    - {{this.test_id}}: Variant {{this.winner}} improved {{this.kpi}} by {{this.uplift}}%
  {{/each}}
- Recent churn patterns (if any): {{churn_data}}
- Product changes or roadmap shifts: {{roadmap_updates}}

Your output must include:
- Growth hypothesis
- Recommended growth loop (e.g., onboarding, referral, upsell)
- At least one experiment with defined KPI, hypothesis, and variant structure
- YAML-formatted strategy blueprint
- Reasoning trace: Why this loop, why this test?

Be specific, edition-aware, and traceable. Avoid generic advice. Tie everything to measurable outcomes.

🧩 Example Prompt Injection (Rendered)¶

Persona: startup_ops_manager
Edition: lite
Primary KPI: activation_rate

Funnel Observations:
  - Awareness: 7.5%
  - Activation: 1.8%
  - Retention: 0.9%
  - Referral: 0%
  - Revenue: 0.3%

Feature usage:
  - smart_calendar: -30% (usage dropped after onboarding tweak)

A/B Test Results:
  - test-lite-onboard-modal-v1: Variant B improved activation by +11.2%

Recent churn:
  - "Missing integrations", "too complex", "slow onboarding"

Your task: Generate a Lite-edition growth strategy focused on improving activation for startup_ops_manager. Use onboarding loop, propose a test, output YAML, and explain your reasoning.

✅ Summary¶

The Input Prompt Template ensures the Growth Strategist Agent:

✅ Understands context
✅ Thinks like a conversion analyst
✅ Outputs structured YAML
✅ Embeds causality and traceability

The agent doesn’t start with “an idea” — it starts with strategic signal conditioning.

📤 Output Expectations¶

The Growth Strategist Agent produces outputs that are not only strategically valuable, but also machine-readable, versioned, and ready-to-execute by downstream agents and DevOps pipelines. These outputs must meet structural, semantic, and operational standards to ensure their reuse, observability, and downstream traceability.

🎯 Output Structure Requirements¶

Output Layer	Expectation
📦 Format	YAML (primary), optionally Markdown summary for human review
🧠 Strategy Reasoning Trace	Explanation of hypothesis → loop → experiment linkage
🧪 Test Definition	One or more well-formed A/B test specs with variant metadata
📈 KPI Association	Explicit mapping to a single primary KPI and optionally secondary KPIs
🧩 Persona & Edition Tags	All strategies must include `persona_id` and `edition_id`
🔁 Feedback Channel Metadata	Where to send results post-execution (e.g., Observability Agent endpoint)
🕸 Traceability Fields	`strategy_id`, `trigger_event_id`, `timestamp`, `agent_instance_id`

📄 YAML Blueprint Output (Template)¶

strategy_id: gs-lite-202406-1
generated_by: growth_strategist_agent
timestamp: 2024-06-15T12:40:00Z
trigger_event: feature_usage_analyzed
persona_id: startup_ops_manager
edition_id: lite
primary_kpi: activation_rate
growth_hypothesis: |
  Users fail to complete onboarding due to lack of visual guidance. A checklist or visual progress bar may boost completion.
recommended_loop:
  type: onboarding_guided_completion
  components:
    - onboarding checklist
    - email nudges (days 1/3/7)
    - CTA on dashboard
experiments:
  - test_id: abt-onboard-checklist-vs-progressbar
    kpi: activation_rate
    hypothesis: A visible checklist will increase onboarding completion rate by 20%
    variants: 2
    variant_a: Visual checklist
    variant_b: Progress bar
    assigned_agent: ab_testing_agent
feedback_to:
  - observability_agent
  - customer_success_agent
strategy_trace:
  reasoning_summary: "Checklist mimics a high-performing flow seen in startup_hr_manager cohort in Pro edition"

🔄 Output Postconditions¶

After emitting output, the agent:

Notifies downstream agents (via MCP signals or direct payloads)
Stores a versioned copy in the memory store and blob storage
Logs metadata into telemetry layer for traceability and metrics tracking

📎 Human Review Option¶

Some outputs can be marked with:

review_required: true
review_reason: "New edition-targeted loop; insufficient prior memory context"

This allows platform users or reviewers to validate before execution, especially for high-risk experiments or novel loop types.

✅ Summary¶

The Growth Strategist Agent’s outputs are:

✍️ Structured
📎 Traceable
🧪 Hypothesis-driven
📈 KPI-aligned
🧠 Explainable

This isn’t just strategy — it’s executive-level, autonomous go-to-market command logic.

🧠 Memory Design: Short-Term and Long-Term¶

The Growth Strategist Agent relies on an advanced dual-memory system that combines short-term tactical context and long-term strategic memory. This enables it to reason contextually while learning from historical outcomes, personas, experiments, and market dynamics — all aligned with ConnectSoft's observability-first, memory-enriched agent design.

🧠 Short-Term Memory (Contextual)¶

Characteristic	Description
Scope	Current task context — input signals, KPIs, persona, funnel state, roadmap
Duration	Lasts per request session (up to GPT-4o context window limits)
Includes	Most recent A/B test results, feature usage drops, and active funnel summary
Usage	Drives immediate reasoning and generation, especially during trigger analysis
Storage Mechanism	Embedded in prompt input, serialized JSON state, or Azure Table checkpoint

🧠 Long-Term Memory (Persistent)¶

Memory Type	Description
🧬 Semantic Vector Memory	Stores growth loops, failed strategies, A/B test variants, onboarding loops
📚 Strategy Outcome Archive	YAML/JSON blueprints with timestamp, persona, edition, result, and feedback
📎 Trace Log Memory	Links all strategies to inputs, variant results, funnel changes
📂 Growth Loop Ontology Graph	Internal graph structure mapping loops to outcomes, KPIs, segments

🗂️ Memory Index Tags¶

All memories include metadata fields for:

persona_id
edition_id
strategy_id
input_trace_id
outcome_snapshot
model_version
run_timestamp

This enables semantic search, backward tracing, and variant avoidance.

🔍 Sample Long-Term Memory Entry (Simplified)¶

{
  "strategy_id": "gs-lite-202403-1",
  "persona_id": "clinic_admin",
  "edition_id": "lite",
  "loop_type": "onboarding_checklist",
  "primary_kpi": "activation_rate",
  "result": {
    "variant_winner": "checklist",
    "uplift": 17.4,
    "confidence": "high"
  },
  "timestamp": "2024-03-28T09:22:00Z"
}

🔁 Memory Usage in Execution¶

Use Case	How Agent Uses Memory
⚠️ Strategy Collision Avoidance	Detects if similar loop already failed in same persona/edition
📈 Success Amplification	Finds strategies with highest uplift in similar cohorts
🧠 Prompt Augmentation	Injects summarized memory blocks into reasoning phase
🕵️‍♂️ Traceability Chain	Links outputs to past runs for dashboard observability

🧪 Self-Adaptive Learning¶

The agent adapts over time by:

Reinforcing high-performing loops
Avoiding redundant experiments
Optimizing prompt reasoning with learned biases
Linking KPI impact to strategy types over time

✅ Summary¶

The Growth Strategist Agent’s memory system makes it:

📚 Historically intelligent
📎 Auditable
🔁 Self-improving
🔍 Context-aware

Its memory isn’t passive — it’s the strategic brain behind every growth move.

✅ Validation¶

To ensure strategic accuracy, test feasibility, and operational soundness, the Growth Strategist Agent integrates multi-layered validation logic into its execution flow. Validation occurs before emitting outputs and before pushing tasks to downstream agents.

🔍 Validation Objectives¶

Confirm that recommendations are testable, not theoretical
Ensure strategies align with persona and edition constraints
Avoid duplication of failed or recently run strategies
Flag outputs needing human review
Maintain traceability for observability and rollback

🧪 Types of Validation Checks¶

Layer	Validation Logic
🎯 KPI Mapping	Ensures that every growth hypothesis is explicitly tied to a measurable KPI
🔁 Hypothesis Soundness	Validates hypothesis structure (if/then), testability, and metric alignment
🧠 Memory Collision Check	Uses vector similarity and trace logs to detect repeated or conflicting loops
👥 Persona-Edition Alignment	Verifies tone, value props, and loops are relevant to the given persona
🧪 Experiment Design	Checks for variant sufficiency, proper structure, and assigned test agents
🧾 Output Schema Compliance	YAML structure is schema-validated before being emitted

🧩 Example: KPI Validation Snippet¶

growth_hypothesis: "If users see a visual checklist, they'll be more likely to complete onboarding."
primary_kpi: activation_rate ✅

🚫 Invalid case (flagged):

growth_hypothesis: "Checklists are good." ❌
primary_kpi: undefined ❌

⚠️ Flagging Risky Outputs¶

Scenario	Action Taken
New loop with no past memory	Flag as `review_required: true`
Colliding strategy found in last 30 days	Auto-reject unless feature or edition materially changed
KPI not in known metrics	Soft warn + prompt agent to revise or refine
Missing persona-specific adjustments	Warning + template fallback

🧪 Validation Result Tags¶

Each output receives tags such as:

validation:
  status: passed
  conflicts_found: 0
  review_required: false
  risk_score: 0.12
  trace_id: "evt-usage-drop-lite-ops"

This metadata becomes part of the observability trail and decision history.

🤝 Optional Human-in-the-Loop¶

For risky or novel strategies, validation subsystem may trigger a:

Human review prompt
Fallback to conservative defaults
Request for more data before generation proceeds

✅ Summary¶

The Growth Strategist Agent doesn’t just generate — it validates with:

💡 Test logic
🔍 Memory awareness
📎 Schema compliance
📊 KPI enforcement

Growth without validation is guesswork. This agent makes sure it’s science-backed, not just data-themed.

🔁 Retry and Correction Flow¶

The Growth Strategist Agent implements a robust correction and retry mechanism to maintain output quality, prevent invalid decisions, and enable self-healing behavior when inputs are missing, memory conflicts occur, or reasoning fails.

This ensures that growth strategies are not only generated — but continuously refined until valid, executable, and traceable.

🔄 Retry Triggers¶

Scenario	Triggered Retry Type
🚫 Failed validation	Regeneration with stricter prompt instructions
🔁 Conflicting past strategy detected	Request memory override or edition exception
🔍 Missing KPI or experiment details	Prompt retry with enhanced scaffolding
❌ Incomplete YAML output	Forced retry with schema enforcement
⚠️ Low confidence reasoning (< threshold)	Adjust temperature / reframe reasoning path

🔧 Correction Process Phases¶

flowchart TD
    A[Initial Output Generated] --> B[Validation Fails or Conflict Detected?]
    B -->|Yes| C[Retry: Enhanced Prompt or Memory Override]
    C --> D[Re-validate Output]
    D -->|Pass| E[Emit Output + Store Trace]
    D -->|Fail Again| F[Trigger Human Intervention or Fallback Strategy]

Hold "Alt" / "Option" to enable pan & zoom

🛠 Correction Tools and Mechanisms¶

Mechanism	Description
✏️ Enhanced Prompt Reframing	Injects missing context or more rigid instruction into retry prompt
🧠 Semantic Memory Override	Allows soft-deletion or conditional override of conflicting historical loops
🧩 Fallback Loop Generator	Produces conservative defaults (e.g., checklist onboarding if unsure)
🔎 Debug Flag Injection	Activates detailed reasoning trace for inspection or human review
📚 Prompt Postmortem Log	Captures original input, reasoning path, failure point, and retry metadata

🧠 Example: Correction Cycle Flow (Test Hypothesis Retry)¶

1. Initial output: "Improve onboarding"
2. Validation failed: No KPI, no test, vague strategy
3. Retry triggered → Prompt updated: "Explicitly define KPI, add 1 experiment, target Lite edition"
4. Output now includes:
   - Hypothesis
   - Onboarding loop type
   - Test plan
   - YAML blueprint ✅

🔁 Retry Metadata Tracked¶

retry_info:
  retried: true
  reason: "Missing KPI and hypothesis"
  attempts: 2
  resolved_on: second_pass

🧠 Learning from Retries¶

Each retry updates:

Memory trace (e.g., “required experiment injection”)
Prompt templates (e.g., “add loop scaffold for onboarding”)
Strategy scoring model (penalize repeated vague outputs)

✅ Summary¶

The Growth Strategist Agent is not fragile:

It retries with intelligence
It escalates when needed
It adapts templates for future robustness

Retry is not failure — it's strategic refinement in progress.

🤝 Collaboration Interfaces¶

The Growth Strategist Agent plays a central coordinating role in ConnectSoft’s Growth, Marketing & Customer Success cluster. It both consumes intelligence from upstream agents and emits validated strategy payloads to downstream agents — forming a closed-loop cycle of signal → strategy → execution → feedback.

Its interfaces are standardized using MCP server APIs, event signals, vector memory, and YAML blueprints.

🔄 Inbound Interfaces (Receives Data From)¶

Source Agent / System	Interface Type	Purpose
🧠 Marketing Specialist Agent	MCP Event: `campaign_started`	Provides campaign tone, persona focus, early CTR feedback
📈 Observability Agent	MCP Event: `feature_usage_analyzed`, `metric_regression`	Provides funnel leaks, adoption gaps, churn signals
🧪 A/B Testing Agent	API Callback / Event: `test_results_available`	Provides experiment outcomes for memory and retraining
🎧 Customer Success Agent	MCP Stream: `csat_drop`, `nps_flagged`, `churn_logged`	Informs about qualitative and trend-based customer issues
📂 Vector Memory Store	Semantic Search API	Enables similar-strategy recall for reusability and avoidance

📤 Outbound Interfaces (Sends Data To)¶

Target Agent / System	Interface Type	Purpose
🧪 A/B Testing Agent	MCP Emit: `test_blueprint_ready`	Delivers prioritized experiments tied to growth hypotheses
📈 Observability Agent	Event Emit: `growth_strategy_emitted`	For metric tracking and follow-up telemetry hooks
🎧 Customer Success Agent	MCP Emit: `persona_retention_loop`	Sends re-engagement or upsell loop ideas for account health
📥 Memory Indexing System	Internal Save Event / Blob write	Stores YAML strategy, test outcomes, and traceability logs
🧠 Marketing Specialist Agent	Optional Event Emit: `loop_alignment_needed`	Requests aligned messaging for onboarding loops

🕸️ Agent Interaction Graph (Mermaid)¶

flowchart LR
    OBS[Observability Agent] --> GS[Growth Strategist Agent]
    MSA[Marketing Specialist Agent] --> GS
    CSA[Customer Success Agent] --> GS
    GS --> ABT[A/B Testing Agent]
    GS --> OBS
    GS --> CSA

Hold "Alt" / "Option" to enable pan & zoom

📡 Message Formats and Protocols¶

Interface Type	Format/Protocol	Example Payloads
MCP Event Emit	JSON + Trace Headers	`{"strategy_id": "...", "kpi": "activation_rate"}`
MCP Event Consume	Structured Input Schema	Parsed into prompt templates or semantic memory
API Callback/Webhook	REST + Auth Header	`/ab-test-results/submit?strategyId=gs-202406-2`
Semantic Memory	Embedding API + Tags	Query: `persona_id=startup_hr_manager`

🤝 Human Collaboration Hooks¶

Mode	Trigger Condition	Interface
❓ Strategy Review	Novel loop type, risk score > threshold	UI prompt in dashboard
⚠️ Edition Conflict	Loop suggests wrong edition alignment	Analyst review + override
🧪 Test Injection Approval	Unusual variants or KPI targets	A/B lead confirms

✅ Summary¶

The Growth Strategist Agent doesn’t work in isolation — it’s a growth mesh router between insight, strategy, test, and outcome:

Pulls signals from across the Factory
Pushes strategy to execute and learn
Collaborates like a strategist, behaves like a system

It turns the ConnectSoft platform into a growth engine with memory, feedback, and evolution.

📊 Observability Hooks¶

To uphold ConnectSoft’s observability-first principle, the Growth Strategist Agent is fully instrumented with metrics, traces, logs, and telemetry events. These observability hooks enable debugging, confidence scoring, performance tracking, and closed-loop feedback — across both human and automated agents.

📈 Core Observability Layers¶

Layer	Purpose
📍 Traceability Layer	Links all inputs, outputs, memory references, retries, and collaboration calls
📊 Metrics Layer	Exposes agent-level KPIs, decision stats, and retry outcomes
📋 Logging Layer	Captures semantic reasoning logs and edge-case failures
🔄 Feedback Layer	Accepts runtime results (uplift, confidence, A/B test outcomes) to train memory

📌 Key Trace Identifiers¶

Identifier Key	Description
`strategy_id`	Unique UUID for the generated growth blueprint
`trigger_event_id`	The originating funnel signal that invoked the agent
`agent_instance_id`	Correlates execution with Semantic Kernel session
`retry_attempts`	Count of validation or generation retries
`memory_reference_ids`	List of historical entries pulled from memory

📊 Key Agent Metrics¶

Metric Name	Description
`growth_strategies_generated_total`	Cumulative count of strategies emitted
`retry_ratio`	Percentage of generations requiring retry
`kpi_target_distribution`	Count per primary KPI (activation, retention, etc.)
`strategies_per_edition`	Edition-wise distribution of growth output
`loop_type_prevalence`	Frequency histogram of recommended growth loops
`review_required_rate`	% of outputs flagged for human review

📘 Exposed via: Azure Monitor, OpenTelemetry, and optional Prometheus exporter

📋 Logging and Audit Trails¶

Log Level	Example Contents
`INFO`	Agent activated with context summary, memory recall result
`DEBUG`	Prompt injected, function plan, reasoning trace (token-capped)
`WARN`	Memory collision detected, invalid KPI assignment
`ERROR`	YAML structure invalid after retries, escalated to human override
`TRACE`	All inbound/outbound events and exact retry decision logic

Logs are stored in:

Azure Application Insights
ConnectSoft Audit Table Store (optional)
Developer Debug UI panel (in sandbox mode)

🔄 Feedback Ingestion (Telemetry Results)¶

Feedback Source	Accepted Format / Endpoint	Use Case
A/B Testing Agent	JSON event via MCP API	Loop reinforcement / adjustment
Observability Agent	KPI delta, funnel movement post-strategy	Re-training and memory scoring
Human Analyst Portal	Manual approval/rejection flags	Review loop performance signals

📡 Sample Telemetry Event (Strategy Feedback)¶

{
  "strategy_id": "gs-lite-202406-2",
  "test_result": {
    "variant_winner": "checklist",
    "uplift": 14.2,
    "confidence": "high"
  },
  "executed_by": "a/b_testing_agent",
  "kpi_impact": {
    "activation_rate": {
      "before": 2.1,
      "after": 3.5
    }
  }
}

Automatically updates long-term memory and training data for loop recurrence.

✅ Summary¶

The Growth Strategist Agent is fully observable:

📈 Emits metrics on everything it does
🧠 Tracks its memory and outcomes
🔍 Can be audited, replayed, and diagnosed
🔄 Evolves through feedback and telemetry

Without observability, there is no intelligence — only hallucination. This agent sees, learns, adapts, and proves.

🧍 Human Intervention Hooks¶

While the Growth Strategist Agent is designed to operate autonomously, there are intentional points of human-in-the-loop collaboration where strategic oversight, risk mitigation, or subjective alignment are necessary. These hooks are declarative, observable, and overrideable — ensuring AI-powered growth planning remains transparent and governable.

🧠 When Human Review Is Triggered¶

Condition Type	Description
🚨 High-Risk Strategy	New growth loop for a high-revenue edition or sensitive persona
⚠️ Low Reasoning Confidence	Agent internally scores its reasoning confidence below threshold (e.g., 0.4)
🧪 Unusual Experiment	More than 2 variants, or lacks prior test precedent
📎 Conflicting Historical Memory	Proposed loop matches past failed strategy in same edition/persona
🧩 Unmapped KPI	Suggests a KPI not tracked by Observability Agent or telemetry
🧾 Human Feedback Required Tag	Prompted by agent during generation (e.g., "this needs marketing review")

👁️ Human Review UI (Dashboard)¶

ConnectSoft provides an optional review dashboard where:

Agents send review-required strategies with metadata
Analysts or growth managers inspect the YAML blueprint
Suggested edits, approvals, or rejections are logged
Optionally annotate "why change was made" for training feedback

review_required: true
review_reason: "New loop type for Pro edition; confidence = 0.36"
assigned_reviewer: "growth-lead@connectsoft.ai"

🛠 Available Human Actions¶

Action Type	Description
✅ Approve	Signals downstream agents to execute without modification
📝 Edit + Approve	Modify YAML or hypothesis; annotate correction
❌ Reject	Block strategy execution; optionally suggest retry or clarification
⏳ Defer	Move to backlog; agent won't retry until conditions change
🔁 Retry Manually	Trigger regeneration with hints or prompt edits

🧠 Agent Learning from Human Edits¶

Modified outputs are stored with review_override: true
Reasoning trace + reviewer annotation is embedded in memory
System prompt is subtly adjusted to reflect editing patterns
Confidence model retrains over time to reduce future interventions

🤝 Use Cases That Often Involve Humans¶

Scenario	Role Involved	Why Review?
Pro edition onboarding strategy	Growth Lead	High-revenue customer impact
Experimental referral mechanics	Marketing / Legal	Branding or incentive conflict potential
Retention loops with CSAT triggers	Customer Success Leader	Need qualitative signal alignment
Unknown persona detected	Product Manager	Persona segmentation misalignment

✅ Summary¶

The Growth Strategist Agent respects:

✅ Strategic risk
✅ Subjectivity in tone and targeting
✅ Edition priority and company thresholds

It's not just intelligent — it's governable by design.

Autonomy is powerful — but alignment with human goals is non-negotiable.

🧾 Summary and Conclusion¶

The Growth Strategist Agent serves as the strategic brain of the ConnectSoft AI Software Factory’s Growth, Marketing & Customer Success cluster — translating telemetry signals, persona behaviors, and funnel trends into autonomous, testable growth strategies.

🧠 Core Mission¶

Transform observed product signals and customer behavior insights into:

🎯 Measurable growth hypotheses
🔁 Edition-aware growth loops
🧪 Executable A/B tests
📈 KPI-targeted experiments

It functions after product delivery and GTM preparation, bridging marketing, telemetry, and experimentation into a closed feedback loop.

🔗 Cluster Positioning¶

Layer	Role
Growth Engine Core	Converts data → insights → strategy → test → telemetry → memory loop
Persona Edition Aligner	Ensures unique strategies per edition-persona combination
Multi-Agent Coordinator	Connects with Observability, Marketing, A/B Testing, and CS Agents

flowchart TD
    OBS[Observability Agent] --> GS[Growth Strategist Agent]
    MSA[Marketing Specialist Agent] --> GS
    CSA[Customer Success Agent] --> GS
    GS --> ABT[A/B Testing Agent]
    GS --> CSA
    GS --> OBS

Hold "Alt" / "Option" to enable pan & zoom

🧩 Key Features¶

🔍 Funnel-Aware Reasoning: Awareness → Activation → Retention → Revenue
📦 YAML Blueprint Emission: All strategies are reproducible, auditable, and traceable
🧠 Memory-Backed Strategy Recall: Avoids failed tests, learns from uplift
🛡️ Human Review Hooks: For high-risk, untested, or misaligned strategies
🔁 Retry + Correction Engine: Guarantees structurally and semantically sound output
📡 Full Observability: Metrics, logs, traces, confidence scoring, and telemetry feedback

🔚 Without It…¶

❌ Marketing strategies remain static ❌ Growth hypotheses rely on human guesswork ❌ Edition segmentation is not acted on ❌ Retention loops and telemetry have no response path

With this agent, growth becomes systematized, compounding, and traceable.

✅ Conclusion¶

The Growth Strategist Agent is not just a tool — it is a continuous experiment generator, a funnel optimizer, and a strategic advisor backed by memory, telemetry, and coordination.

It’s what makes ConnectSoft’s software not only shippable, but scalable.

🧾 System Prompt¶

The System Prompt defines the core behavioral instruction for the Growth Strategist Agent — guiding its identity, tone, reasoning style, and output constraints from the moment it's instantiated. This is injected at agent bootstrap within the Semantic Kernel or MCP runtime orchestration.

🧠 Purpose of System Prompt¶

Sets the agent persona and mission scope
Locks in output expectations (YAML, strategy, experiments)
Enforces tone: strategic, analytical, hypothesis-driven
Prevents deviation from ConnectSoft’s growth loop methodology
Helps standardize collaboration across editions and personas

🧾 Canonical System Prompt¶

You are the Growth Strategist Agent in the ConnectSoft AI Software Factory.

Your core mission is to generate data-driven, persona-aware, edition-specific growth strategies that accelerate user acquisition, activation, retention, and revenue.

You operate after a product or feature is shipped and analyzed via telemetry. Based on funnel state, behavioral signals, and persona metadata, you will identify the most critical bottleneck and propose a measurable, testable growth hypothesis.

Each strategy must:
- Target a specific persona and edition
- Be focused on one primary KPI (e.g., activation_rate, retention_30d, revenue_per_user)
- Recommend a growth loop (onboarding, referral, upsell, reactivation, etc.)
- Include one or more A/B test blueprints with defined hypotheses and variants
- Be output in a YAML blueprint structure
- Include a traceable reasoning summary

You must avoid:
- Generic advice or vague growth tactics
- Suggestions that don’t match product edition or persona tone
- Repeating failed strategies from memory unless a material change has occurred

You work collaboratively with:
- Observability Agent (signal intake, metric movement)
- Marketing Specialist Agent (messaging alignment)
- A/B Testing Agent (test execution)
- Customer Success Agent (retention loops)

If any required input is missing or ambiguous, you must request clarification or propose a conservative default.

Your responses must be structured, explainable, and production-ready.

🧭 What This Prompt Enables¶

Behavior	Enabled Outcome
🎯 Strategy precision	Always starts from signal + persona + edition
🧠 Memory recall discipline	Avoids failed loops, reinforces successful ones
📊 KPI anchoring	Keeps outputs tied to measurable results
🔁 Loop-first thinking	Drives toward actionable onboarding, upsell, or retention loops
🧪 Experiment mindset	Every strategy becomes a testable hypothesis
🧾 YAML-first formatting	Outputs usable by downstream agents and DevOps automation layers

🧠 Memory-Influenced Prompt Variants¶

At runtime, the system prompt may be soft-modified by memory-based overlays:

“You’ve previously tested similar loops in this edition. Be innovative.”
“This persona responded best to reactive engagement loops in the past.”
“Avoid onboarding strategies; activation issue is not onboarding-related.”

✅ Summary¶

The system prompt anchors the agent’s intelligence, ensuring it behaves like:

A senior growth strategist
With product telemetry access
A/B testing playbooks
Memory of past wins/losses
Connected to the multi-agent fabric of the platform

It doesn’t just generate. It advises, tests, evolves, and connects.

📥 Input Prompt Template¶

The Input Prompt Template defines how the agent receives and interprets structured signals from the platform — transforming them into context-rich, reasoning-ready prompts that activate the strategy generation process.

This ensures that inputs are semantic, structured, and standardized across all triggering sources (Observability Agent, A/B Testing Agent, Customer Success Agent, etc.).

🧾 Template Format (Pre-filled Instruction + Context Blocks)¶

You are the Growth Strategist Agent. Based on the following input signals, generate a growth strategy to address the bottleneck.

Use the YAML format shown below. Include reasoning trace and at least one A/B test suggestion.

---

📌 Product Context
- Product: {{product_name}}
- Edition: {{edition_id}}
- Feature/Module: {{feature_name}}

🎯 KPI Signal
- Trigger Event: {{event_type}} (e.g., funnel_drop, adoption_flatlined)
- KPI Affected: {{primary_kpi}}
- Metric Delta: {{metric_before}} → {{metric_after}} (% delta: {{percent_change}})
- Time Range: {{start_date}} to {{end_date}}

👤 Persona Info
- Persona ID: {{persona_id}}
- Segment: {{industry}}, {{team_size}}, {{maturity_level}}

🧠 Memory Summary
{{relevant_strategy_memory_summary}}

---

Generate:
- A hypothesis tied to the persona’s context
- A growth loop suggestion
- A/B test plan(s) with variants
- A traceable reasoning explanation
- YAML blueprint (machine-readable)

🔁 Prompt Variable Examples¶

Variable	Example Value
`product_name`	“ConnectSoft CRM”
`edition_id`	`pro`
`feature_name`	“Onboarding Dashboard”
`event_type`	`activation_rate_drop`
`primary_kpi`	`activation_rate`
`metric_before/after`	`4.2` → `3.1`
`persona_id`	`startup_founder_hr`
`relevant_strategy_memory_summary`	“2 prior onboarding loops tested in Q1; checklist won over progress bar in similar cohort”

🧠 Memory Injection Block¶

The {{relevant_strategy_memory_summary}} is auto-filled with:

Last 3 strategies for same edition/persona
Uplift or failure feedback
Variant performance
Notes on experiment saturation

This allows context-aware avoidance or amplification.

✅ Template Benefits¶

Benefit	Description
🧩 Modular	Works across multiple signal types (drop, stagnation, churn, etc.)
🧠 Memory-Enriched	Prompts reflect prior experiments and outcomes
🧪 Action-Oriented	Encourages loop thinking + test design
🔍 Structured	Ideal for auditing, postmortem, and retry tuning

✅ Summary¶

The input prompt is not a generic question — it's a fully structured context framework that primes the agent to:

Think strategically
Reason from memory
Act within constraints
Output with precision

Strategy starts with the right question, asked the right way.

📤 Output Expectations and Format¶

The Growth Strategist Agent produces machine-usable, human-readable, versioned YAML blueprints that encode:

🎯 Growth hypotheses
🔁 Recommended loops
🧪 A/B test scaffolding
📊 KPI targeting
🧠 Memory trace references
🧾 Confidence metadata

These outputs are consumed by downstream agents, indexed for feedback learning, and optionally reviewed by humans.

📦 Expected Output Structure¶

strategy_id: gs-{{edition_id}}-{{timestamp}}
persona_id: startup_founder_hr
edition_id: pro
created_at: 2025-06-14T08:21:00Z

growth_hypothesis: >
  If users are guided through a checklist-style onboarding instead of a generic dashboard,
  they will complete initial setup faster and reach first value sooner.

primary_kpi: activation_rate
growth_loop_type: onboarding_checklist

experiments:
  - id: exp-001
    hypothesis: Checklist onboarding improves activation
    variants:
      - name: checklist_ui
        description: Guided visual checklist with task completion tracking
      - name: default_dashboard
        description: Status quo dashboard with minimal guidance

reasoning_trace: |
  Based on a 26% drop in activation in the Pro edition post-onboarding UI release,
  and past success in similar cohorts (uplift +17.4%),
  checklist loops historically perform better with solo startup founders.

memory_references:
  - strategy_id: gs-pro-202503-2
    result: success
    uplift: 17.4
    confidence: high

validation:
  status: passed
  review_required: false
  confidence_score: 0.84

📊 Output Dimensions¶

Field	Description
`strategy_id`	Unique, versioned strategy blueprint
`persona_id`	Persona segment the strategy targets
`growth_hypothesis`	The "if...then" behavior claim being tested
`growth_loop_type`	Structured type: `onboarding_checklist`, `referral_incentive`, etc.
`primary_kpi`	One of `activation_rate`, `retention_30d`, `ltv`, `trial_to_paid`
`experiments`	Variant blueprints with IDs and behavioral deltas
`reasoning_trace`	Human-readable strategic logic trace
`memory_references`	Links to similar past strategies
`validation`	Confidence, flags, status, risk score

📎 Format Requirements¶

Constraint	Details
YAML Compliant	Must be valid, well-indented YAML
Versioned	Includes date-timestamp or semver suffix in `strategy_id`
Taggable	Easily indexable by `persona_id`, `loop_type`, and `kpi`
Feedback-Ready	Accepts telemetry appends (`test_result`, `uplift`, `confidence`)
Reusable	Can be passed to A/B Testing Agent without modification

📤 Emission Targets¶

✅ Stored in memory graph index
✅ Sent to A/B Testing Agent (via MCP event)
✅ Sent to Observability Agent for future KPI trace correlation
🔄 Optionally routed to UI for human approval

✅ Summary¶

The Growth Strategist Agent doesn’t just “answer” — it emits executable growth artifacts, versioned, reasoned, and traceable:

Every output becomes part of the machine-governed growth brain — not just a document, but a loop.

🧠 Memory and Versioning Practices¶

To enable strategic evolution, anti-redundancy, and continuous learning, the Growth Strategist Agent employs multi-scope memory design, combining vector embeddings, event references, and output versioning.

It doesn’t just recall — it compares, scores, clusters, and adapts.

🧩 Memory Scopes¶

Scope	Contents
🔄 Short-Term Contextual	Signals, KPI deltas, current persona, edition snapshot
📦 Long-Term Strategic	Past YAML blueprints (strategy, loop, test) with results
🧠 Semantic Embedding	Vectorized traces of reasoning, hypotheses, loop tags
📚 Outcome-Based Memory	Stores A/B test results, retention curves, uplift deltas
🔒 Immutable Audit Store	Write-once snapshots for governance and rollback

🧠 Example Memory Record¶

{
  "strategy_id": "gs-pro-202404-2",
  "persona_id": "startup_founder_hr",
  "loop_type": "onboarding_checklist",
  "kpi_target": "activation_rate",
  "uplift": 17.4,
  "variants": ["checklist_ui", "default_dashboard"],
  "result": "success",
  "confidence": "high",
  "execution_period": "2024-04-15 to 2024-05-05"
}

🧠 Semantic Memory Embeddings¶

Each hypothesis, loop suggestion, and experiment gets embedded using:

OpenAIEmbeddingGenerator
Labeled by persona, edition, KPI
Indexed using Azure AI Search or vector DB like Weaviate

Enables “show me similar onboarding failures in Pro edition for solo founders” queries.

🧬 Versioning of Outputs¶

Rule	Enforcement
`strategy_id` uniqueness	Based on edition, timestamp, and hashed prompt
Output diffs tracked	Uses YAML diffing for delta insights across re-generations
Memory linkage	Traceable from new strategies to past versions for reasoning reference
Immutable after execution	Emitted blueprints are locked to preserve experimental validity

🔄 Memory Feedback Integration¶

As telemetry arrives:

Memory entries are scored and updated
Future prompts are influenced by uplift trends
Poor-performing loops are deprioritized
Exceptional strategies are tagged as seed recommendations

🔍 Memory Access APIs¶

Function	Description
`search_by_persona_and_kpi()`	Find past loops by target persona and KPI
`get_strategy_lineage()`	Show version history and outcome of similar strategies
`suggest_loop_based_on_uplift()`	Recommend loop types with highest success for given context

✅ Summary¶

The Growth Strategist Agent learns like a strategist:

📊 Tracks what worked — and what didn’t
🧠 Embeds learnings into next cycle’s thinking
🔐 Ensures version traceability and auditability

Memory isn’t a bonus — it’s the core of evolutionary growth intelligence.

🧩 Final Conclusion and Cluster Integration Map¶

The Growth Strategist Agent is the central orchestrator of continuous product-led growth in the ConnectSoft AI Software Factory. It doesn’t just respond — it observes, hypothesizes, tests, recalls, and optimizes — turning telemetry and product intent into repeatable, validated growth loops.

✅ Recap of Agent Capabilities¶

Dimension	Description
🎯 Strategic Role	Converts telemetry signals into executable growth strategies
🧠 Persona Awareness	Aligns strategies with persona pain-points and funnel positions
🧪 Experiment Generation	Produces A/B test blueprints with hypotheses, variants, and traceability
📈 KPI Anchoring	Optimizes for activation, retention, monetization, or virality
🔄 Loop Thinking	Suggests onboarding, upsell, referral, reactivation, and cross-sell loops
🧾 YAML Blueprint Output	Structured, machine-consumable strategy artifacts
🔁 Retry and Validation	Ensures all outputs are validated, auditable, and reusable
🧠 Memory Management	Recalls, scores, avoids, and improves from prior outcomes
🤝 Cross-Agent Orchestration	Connects seamlessly to A/B Testing, Observability, Marketing, CS Agents
📡 Observability Hooks	Fully traceable, telemetry-ready, and confidence-scored
🧍 Human Review	Incorporates governance checkpoints when necessary

🔗 Cluster Integration Map¶

flowchart TB
    subgraph PRODUCT INSIGHTS
        OBS[Observability Agent]
        CSA[Customer Success Agent]
    end

    subgraph GROWTH STRATEGY
        GS[Growth Strategist Agent]
    end

    subgraph EXECUTION
        ABT[A/B Testing Agent]
        MSA[Marketing Specialist Agent]
    end

    OBS -->|Funnel Drop / Metric Change| GS
    CSA -->|Churn / NPS Signal| GS
    GS -->|Loop & Test Blueprint| ABT
    GS -->|Messaging Realignment| MSA
    GS -->|Retention Loop Handoff| CSA

Hold "Alt" / "Option" to enable pan & zoom

📦 Cluster Position: Growth, Marketing & Customer Success¶

Sub-Cluster	Agent Role	Triggered From	Feeds Into
📈 Growth Strategy	Growth Strategist Agent	Observability, CSA	A/B Testing, Marketing, CS
🧠 Marketing	Marketing Specialist Agent	Product Plan, Persona	Growth Strategist, GTM
🧪 Experimentation	A/B Testing Agent	Growth Strategist	Observability
🤝 Customer Ops	Customer Success Agent	Growth Strategist	Re-engagement Campaigns

🏁 Final Statement¶

The Growth Strategist Agent gives the ConnectSoft Factory its growth IQ.

It translates signals into impact.
It evolves with feedback.
It connects memory to action.
It drives the system from launch to scale.