The Four Layers

The architecture separates concerns into four distinct, independently scalable layers. This design allows agents to hot-load without redeployment, context to persist across all channels, and the system to degrade gracefully when components fail.

↯ Why This Architecture Wins

1. Hot-Loading Without Redeployment

Problem: Traditional deployments require downtime, testing pipelines, and approval processes. Making a small agent tweak could take days.

Solution: Locally, the Brainstem re-reads the agents folder on every request, so a saved file is live on the very next question. In the cloud, agents live in the Azure File Share's agents/ directory and the Intelligence Layer refreshes them on a five-minute cache. Drop in a new Python file, and it's live instantly.

2. Universal Context Across All Channels

Problem: User tells AI something at work. They go home and use a different app. The AI has amnesia.

Solution: Memory is stored by user_guid in Azure File Storage, not tied to any interface. Whether they're in Teams at work, using a web app at home, or talking on their Apple Watch in the car, the AI has full context.

memory/
├── abc123-user-guid/
│   ├── conversation_history.json
│   ├── preferences.json
│   ├── agents/
│   │   ├── custom-agent-1.py
│   │   └── custom-agent-2.py
│   └── workflows/
│       └── daily-routine.json
└── xyz456-user-guid/
    ├── conversation_history.json
    └── ...

3. Stateless Intelligence Layer = Infinite Scale

The Azure Function that powers the Intelligence Layer is completely stateless. Every request is self-contained:

• Load user memory from Storage Layer
• Load required agents from Storage Layer
• Execute agent logic
• Save updated memory back to Storage Layer
• Return response

Benefit: Horizontal scaling is trivial. Need to handle 10,000 concurrent users? Spin up 10,000 function instances. Azure handles it automatically.

4. Graceful Degradation

Because agents are modular and loaded independently, failures are isolated:

• One agent breaks? Only that capability is lost. Other agents still work.
• Copilot Studio goes down? Backend still works. Connect via direct API.
• File Storage has latency? Implement local caching in the function.

Technical Implementation Details

Intelligence Layer: The "Waiter" Pattern

The core intelligence is modeled like a restaurant:

• The Assistant is the waiter - talks to the customer (user)
• The Agents are the kitchen staff - make the pizza, burger, etc.
• The User doesn't need to know how the kitchen works

Why this matters: Context efficiency. The waiter's conversation with the kitchen (agent calls) is completely separate from the conversation with the customer. The user doesn't see "Calling DynamicRoutePlanningAgent..." debug logs.

# Stateless Azure Function (~1,000 lines total)
def handle_request(user_message, user_guid):
    # 1. Load context
    memory = storage.read_file(f"memory/{user_guid}/conversation_history.json")

    # 2. Dynamically load agents
    available_agents = []
    for agent_file in storage.list_files(f"memory/{user_guid}/agents/"):
        agent = dynamically_import(agent_file)
        available_agents.append(agent)

    # 3. Build system prompt with agent metadata
    system_prompt = f"""
    You are an AI assistant. You have access to these tools:
    {json.dumps([agent.metadata for agent in available_agents])}

    Use tools when needed by outputting:
    TOOL_CALL: agent_name(param1="value1", param2="value2")
    """

    # 4. LLM decides which agent to call
    llm_response = openai_client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_message}
        ]
    )

    # 5. If tool call detected, execute agent
    if "TOOL_CALL:" in llm_response:
        agent_call = parse_tool_call(llm_response)
        agent = next(a for a in available_agents if a.name == agent_call.name)
        result = agent.perform(**agent_call.params)

        # 6. Feed result back to LLM for user-friendly response
        final_response = openai_client.chat.completions.create(
            messages=[
                ...memory,
                {"role": "assistant", "content": llm_response},
                {"role": "tool", "content": result},
                {"role": "user", "content": "Provide a user-friendly summary"}
            ]
        )

    # 7. Save updated conversation
    memory.append({"role": "user", "content": user_message})
    memory.append({"role": "assistant", "content": final_response})
    storage.write_file(f"memory/{user_guid}/conversation_history.json", memory)

    return final_response

Agent Metadata: Self-Documenting Tools

Every agent describes itself using JSON Schema. The Intelligence Layer reads this metadata and generates the system prompt dynamically.

class DynamicRoutePlanningAgent(BasicAgent):
    def __init__(self):
        self.name = "DynamicRoutePlanning"
        self.metadata = {
            "name": self.name,
            "description": "Optimizes field sales routes based on priority, location, and time constraints",
            "parameters": {
                "type": "object",
                "properties": {
                    "salesperson_id": {
                        "type": "string",
                        "description": "ID of the salesperson"
                    },
                    "date": {
                        "type": "string",
                        "description": "Date for route planning (YYYY-MM-DD)"
                    },
                    "priority_accounts": {
                        "type": "array",
                        "description": "List of high-priority account IDs",
                        "items": {"type": "string"}
                    }
                },
                "required": ["salesperson_id", "date"]
            }
        }
        super().__init__(name=self.name, metadata=self.metadata)

    def perform(self, **kwargs):
        # Implementation here
        salesperson = kwargs.get('salesperson_id')
        date = kwargs.get('date')
        priorities = kwargs.get('priority_accounts', [])

        # Business logic: optimize route
        optimized_route = calculate_optimal_route(salesperson, date, priorities)

        return f"Optimized route for {date}: {optimized_route}"

Key Insight: Because agents self-document, the LLM automatically knows when to call them. You can add 100 new agents and the system adapts with zero code changes to the Intelligence Layer.

The Buzz Saw: Heavy Lifting (Building Toward Automation)

Traditional development is like a handsaw. Slow, manual, requires constant human energy. You can only cut so fast, and you get tired.

The vision: AI automation as a buzz saw. Fast, tireless, and you can just "lay on it" with more work. Feed it transcripts, feed it MVPs, feed it feedback - it keeps processing.

Where We're Building Automation (Automation Roadmap):

• Transcript → Project JSON: Extract customer name, stakeholders, MVP, competing solutions, timeline from raw transcript (currently manual)
• MVP → Agent Code: Generate 6-10 Python agents from a validated MVP use case (currently manual)
• Prototype → Video Demo: Create narrated demo video with Azure TTS from prototype walkthrough (currently manual)
• Customer Feedback → Code Updates: Adjust agent logic based on feedback without rewriting from scratch (currently manual)
• Parallel Processing: Work on 20+ projects simultaneously with tooling and documentation (building capacity)

Human Taste: The Critical Quality Gates

The Problem: AI can generate code fast, but it doesn't have judgment. It doesn't know if the code solves a real problem, if it's secure, or if customers will actually pay for it.

The Solution: 6 human "quality gates" where experienced team members apply taste, judgment, and experience to keep the project on track.

The 6 Quality Gates:

The Magic: Each gate takes 15-60 minutes of human time, but prevents days or weeks of wasted AI cycles.

The Risk Elimination Pattern

The biggest risk in traditional software development: spending 6 months on a problem no one cares about.

How This Framework Eliminates That Risk:

Key Insight: By getting customer validation at Step 3 (MVP "poke") and again at Step 8 (working demo), you've had 2 major checkpoints before investing serious time. If they don't like it, you've only spent a few days, not months.

Iterations ≠ Experience - It's About Cycles

Traditional Thinking: "I've been doing this for 10 years, so I have 10 years of experience."

Reality: Experience isn't measured by time spent - it's measured by the number of learning cycles completed. Ten years with few iterations is less valuable than two years with hundreds of rapid feedback loops.

How This Framework Maximizes Iterations:

• Parallel Processing: Work on 20+ projects simultaneously
• Fast Feedback Loops: Days instead of months per cycle
• Structured Quality Gates: Spot issues early, iterate faster
• Pattern Recognition: See the same problems across multiple industries, learn universal solutions

Real Impact: In 6 months using this framework, you'll encounter more edge cases, customer objections, integration challenges, and solution patterns than most developers see in 5 years of traditional development.

Objective

Record and transcribe a customer conversation that identifies: (1) their biggest business problems, (2) the data sources they have access to, and (3) how they currently solve the problem manually.

Duration

30-60 minutes - One focused conversation with the decision maker(s)

Owner

Field Team (Team Members A, B, C, D) - Anyone who interfaces with customers

The Three Critical Questions

Question 1: What are your biggest problems?

Why this matters: Focuses on business value, not technology. Customer describes pain in their own language.

Question 2: What data sources do you have?

Why this matters: AI without data is useless. Need to know what's realistic to access.

Key point: Identify what data sources are required to solve the problem, with a clear caveat up front: if data access isn't available, the project's potential is severely limited. AI systems need data to function effectively - this is a non-negotiable requirement that must be established during discovery.

• CRM systems: Dynamics 365, Salesforce, custom systems
• Document repositories: SharePoint, OneDrive, file shares
• Operational systems: Inventory, scheduling, ticketing systems
• External APIs: Weather, traffic, market data

Question 3: How do you solve this manually today?

Why this matters: The manual process is the blueprint for automation. You're scaling what they already do, not inventing something new.

Key point: The core principle is scaling and automating the existing manual process - not inventing an entirely new workflow. This approach reduces risk and increases adoption because users recognize their familiar process, just faster and more consistent.

How to Conduct the Call

Before the Call:

• Ensure recording is enabled (Teams auto-transcribe, or use Otter.ai)
• Inform participants the call will be recorded
• Have 1-2 key decision makers on the call (not 10 people)

During the Call:

• Let them talk: Your job is to extract their knowledge, not pitch technology
• Ask clarifying questions: "Walk me through exactly what the end user does when they get this request"
• Get specific: Not "we have inefficiencies" but "it takes 20 hours per week to process NDAs manually"
• Note competing solutions: "We looked at Salesforce Agentforce" - this goes into project tracking
• Confirm data access: "Can you give us read access to your Dynamics environment?"

Red Flags to Watch For:

Output

File format: Plain text transcript is ideal. If using Teams, the .vtt file works. Just needs to be readable by the next step's automation.

Objective

Use the Transcript-to-Project Agent to automatically extract structured project data from the raw transcript, then human audit to verify accuracy before proceeding.

Duration

15 minutes - AI processes transcript instantly, human reviews output

Owner

Delivery Team (Team Members A, B) - People who will build the solution need to confirm they understand the problem

✓ Human Audit Checklist

The AI extracted data - now verify it's correct:

• Customer name: Is this the correct legal entity name?
• Stakeholders: Are all decision makers captured with correct titles?
• MVP use case: Does this match what the customer actually said?
• Competing solutions: Did we note who they're comparing us to?
• Timeline: Is the deadline realistic and confirmed by customer?
• Data sources: Are the systems they mentioned captured?

Decision Point

Pass: JSON accurately represents the customer problem → Proceed to Step 3

Fail: Key information missing or incorrect → Schedule follow-up call to clarify

Output

Objective

Generate a clear, concise MVP summary and send it to the customer for validation. This "poke" tests if we understood their problem correctly before investing time in development.

Duration

1-2 hours (manual) - Team member drafts MVP document from project JSON using templates and examples

Owner

Delivery Team - Manual process with plan to automate using LLM-based generation

What is a "Poke"?

A poke is a deliberately lightweight MVP summary - usually 1-2 pages - that describes what you think the customer needs in plain business language.

Why "Poke" Instead of "Requirements Document"?

• Lightweight: 1-2 pages, not 20 pages of requirements
• Plain language: Written for business stakeholders, not engineers
• Invites feedback: "Did we hear you right?" not "Sign off on these requirements"
• Fast turnaround: Sent within 24 hours of discovery call

What Goes In The Poke

Section 1: Problem Statement (2-3 sentences)

Section 2: Proposed MVP Solution (3-4 bullet points)

• What it does: AI agent that generates optimized daily routes based on account priority, location, and time constraints
• Key capabilities:
  • Pulls account data from your CRM automatically
  • Prioritizes high-value accounts and urgent visits
  • Generates turn-by-turn route with estimated times
  • Accessible via Teams mobile app (no new app to install)
• What it doesn't do (scope boundaries): Not replacing your CRM, not doing GPS navigation, not scheduling appointments (just optimizing visits)

Section 3: Data Requirements (simple list)

• Read access to Dynamics 365 Sales (account locations, priority flags)
• Last visit date per account
• Salesperson territories and working hours

Section 4: Success Metrics (how we'll measure success)

• Reduce route planning time from 2-3 hours/day to 5 minutes/day
• Increase daily store visits from average 6 to 8-9 per salesperson
• 100% coverage of high-priority accounts weekly (currently 70%)

Section 5: Timeline & Next Steps (simple roadmap)

• Week 1-2: Build prototype with 1 salesperson territory as test
• Week 3: Demo to your team, gather feedback
• Week 4-6: Refine based on feedback, pilot with 5 salespeople
• Week 7-8: Full rollout to all field sales teams

Automation Process

This step uses the project JSON from Step 2 and an LLM prompt template to generate the poke document:

Generate an MVP "poke" document based on this customer project JSON:

[Insert validated project JSON from Step 2]

The document should be:
- 1-2 pages maximum
- Written in plain business language (not technical jargon)
- Structured as: Problem Statement, Proposed Solution, Data Requirements, Success Metrics, Timeline
- Specific and measurable (not vague "improve efficiency")
- Include scope boundaries (what we're NOT building)
- End with clear next steps for customer to respond

Tone: Professional but approachable. We're confirming we heard them correctly, not pitching a solution.

Output: LLM generates a formatted document (Word .docx or PDF) ready to send to customer

Delivery to Customer

Field team (whoever did the discovery call) sends the poke via email:

Output

Objective

Get explicit customer confirmation that the MVP poke accurately describes what they need. Lock in scope with stakeholder sign-off.

Duration

1-2 days - Waiting for customer to review and respond to the poke

Owner

Field Team - Manages customer communication and captures feedback

Three Possible Outcomes

Outcome 1: ✓ "Yes, that's exactly right"

Next steps:

• Document customer sign-off (email confirmation + stakeholder names)
• Lock MVP scope in project tracker (mark as "Approved - Ready for Development")
• Proceed immediately to Step 5 (Generate Agent Code)

Outcome 2: "Close, but here's what needs to change"

Next steps:

• Capture ALL feedback in writing (don't rely on verbal/phone conversation)
• Feed feedback back to LLM: "Update MVP poke with these customer corrections: [paste feedback]"
• Generate revised poke v2 and re-send to customer
• Repeat Step 4 until you get Outcome 1 (customer approval)

Outcome 3: ✗ "This isn't what we need"

Next steps:

• Schedule follow-up discovery call to re-clarify requirements
• Go back to Step 1 - you missed something fundamental in the initial conversation
• DO NOT proceed to development - you'll build the wrong thing

Audit Checklist Before Proceeding

Before marking this step complete and moving to Step 5, verify:

• Written confirmation: Customer email/message explicitly approving MVP scope
• Stakeholder sign-off: Decision maker (person who approves budget) has approved, not just end users
• Data access confirmed: Customer confirmed we'll get access to the data sources listed
• Timeline agreed: Customer understands and accepts the prototype delivery timeline
• Scope locked: No vague "we'll figure it out later" items - everything is defined

Output

Objective

Create the agent the MVP needs. In practice that is one well-scoped single-file agent exposing several deterministic operations, which is the shape 70 of the 72 published solutions use; split into a multi-agent stack only when the use case genuinely spans separate roles. Each agent is self-documenting, modular, and ready to drop into the Azure Function. (Currently manual development with templates; building toward AI-assisted generation)

Build it as a shell template: the agent's shape stays the same for every customer with this job, and the customer's specifics (which system holds the records, who approves) are content it reads live, never values copied into the code.

Duration

Minutes. A scaffolded agent is generated, smoke-tested and hot-loaded in about fifteen seconds; a hand-written one is live the moment you save the file. Writing the business logic inside it is still the real work.

Then: days to weeks, hand-written, with "reduce to hours" as the goal. That figure is kept in Speed Barriers Broken as the baseline this step was measured against.

Owner

Technical Team - Manual development using templates. Vision: AI-assisted generation with human review

Common Customizations After Generation

The generated code is largely production-ready, but you may need to:

def _get_territory_accounts(self, salesperson_id):
    # TODO: Implement Dynamics 365 query
    return []

def _get_territory_accounts(self, salesperson_id):
    from azure.identity import DefaultAzureCredential
    from dynamics_client import DynamicsClient

    client = DynamicsClient(
        endpoint=os.environ['DYNAMICS_ENDPOINT'],
        credential=DefaultAzureCredential()
    )

    # Customer-specific: Query accounts in territory with last_visit field
    accounts = client.query(
        "accounts",
        filter=f"ownerid eq '{salesperson_id}' and statecode eq 0",
        select="accountid,name,address1_composite,priority,last_visit_date"
    )

    return accounts

Typical Customizations:

• API endpoints: Replace placeholders with actual customer URLs
• Authentication: Add customer-specific auth (OAuth, API keys, etc.)
• Data schemas: Adjust field names to match customer's CRM/database
• Business logic: Fine-tune algorithms based on customer feedback

Output

File structure:

agents/
├── dynamic_route_planning_agent.py
├── shelf_recognition_agent.py
├── promotion_suggestions_agent.py
├── next_best_action_agent.py
├── dynamics_crud_agent.py (helper for CRM operations)
└── manage_memory_agent.py (default agent, always included)

Objective

Technical team reviews the generated agent or agents to verify they're secure, follow best practices, and will integrate correctly with customer systems.

Duration

30-60 minutes - Experienced developer can review 6-10 agents in one sitting

Owner

Technical Team Lead - Someone with Python + Azure experience

✓ Code Review Checklist

1. Security Review

• No hardcoded credentials: All API keys/secrets use environment variables
• Input validation: Required parameters are checked before use
• SQL injection protection: If querying databases, use parameterized queries
• File path sanitization: If reading files, validate paths to prevent directory traversal

2. Error Handling

• Try/except blocks: All external API calls wrapped in error handling
• Logging: Errors logged with context (agent name, parameters)
• Return strings always: Never returns None, dict, or throws exceptions to caller
• Graceful degradation: If one agent fails, others still work

3. Integration Check

• API endpoints: Customer-specific URLs are correct
• Data schema: Field names match customer's actual system
• Authentication: Auth method matches customer's setup (OAuth, API key, cert)
• Dependencies: Any required Python packages listed in requirements.txt

4. Metadata Quality

• Clear descriptions: LLM will understand when to call this agent
• Required params marked: "required" array in JSON Schema is accurate
• Examples in descriptions: Parameter descriptions include example values
• Enum constraints: If param has fixed options, use enum to constrain it

Common Issues to Fix

return {"status": "success", "route": optimized_route}

return f"Route generated successfully: {json.dumps(optimized_route)}"

except Exception as e:
    return "Error occurred"

except Exception as e:
    logging.error(f"Route planning failed for {salesperson_id} on {date}: {str(e)}")
    return f"Error generating route for {salesperson_id}: {str(e)}"

"description": "Handles route planning"

"description": "Optimizes daily sales routes for field reps. Call this when a salesperson says 'plan my route' or 'where should I go today'. Considers account priority, location proximity, and visit history to generate optimal stop order."

Review Metrics

Iterative refinement: The code review process involves an interactive conversation with the AI: request consolidation of redundant agents, ask for functionality splits, adjust implementation details - iteratively refining until the agent files meet quality standards.

Decision Point

Pass: All agents reviewed, minor fixes applied → Proceed to Step 7 (Deploy Prototype)

Fail: Major logic errors or missing integrations → Send feedback to RAPP Agent Generator and regenerate

Output

Objective

Get the agent answering first. On the local tier there is nothing to deploy: install the server with one command, put the reviewed files in its agents folder, and ask. Promote to Azure Functions and Copilot Studio channels when the customer needs to reach it without your laptop.

Time Investment: minutes locally; 1-2 hours for the cloud tiers, with scripts.

Human Role: Manual Azure resource setup, agent deployment, connectivity verification, testing

Automation Vision: ARM templates and deployment scripts to reduce setup time to minutes

Input from Step 6

Deployment Process (2-Step Setup)

Step 7.1: Deploy Azure Infrastructure

Use the Azure ARM template to create all required resources with one click:

Step 7.2: Run Setup Script

Execute the bash/PowerShell script that configures the environment:

# Option 1: Local setup (for testing)
git clone https://github.com/microsoft/aibast-agents-library.git
cd aibast-agents-library
./deploy.sh  # or deploy.ps1 on Windows

# Script installs:
# - Python dependencies
# - Azure SDK
# - Connects to Azure Function App
# - Uploads default agents (memory, email)

# Option 2: Cloud setup (GitHub Codespaces)
# Click "Open in Codespaces" button
# Runs automatically in cloud - no local install needed

Dynamic loading: The setup script automates the entire environment configuration process - downloading dependencies, installing Python packages, connecting to Azure services, and uploading default agents. It handles all the technical plumbing automatically, regardless of whether running locally or in cloud environments.

Step 7.3: Deploy Your Agents

Copy the approved agents from Step 6 into the deployment:

# Local deployment (VS Code)
1. Copy your 6-10 reviewed agent files
2. Paste into /agents directory
3. Right-click → "Deploy to Function App"
4. Select your Azure subscription
5. Deployment completes in 2-3 minutes

# Cloud deployment (drag-and-drop)
1. Open Azure Portal → Your Function App
2. Navigate to File Storage → /agents folder
3. Drag approved .py files directly into folder
4. Agents hot-load automatically (zero downtime)

Step 7.4: Connect to M365 Copilot Studio

Make your agents accessible through Teams, Outlook, and web chat:

1. Download the Copilot Studio solution for your solution: solutions/<slug>/exports/<slug>-copilot-studio-solution.zip, with the deployment settings JSON beside it. One ships per published solution.
2. Import to Power Platform:
   • Go to copilotstudio.microsoft.com
   • Select "Import solution"
   • Upload the .zip file
   • Configure environment variables (Azure Function URL, API key)
3. Enable channels: Check boxes for Teams, Web, Outlook, etc.
4. Publish: One-click publish to M365

M365 integration: The process involves downloading the pre-built Copilot Studio solution, importing it into Power Platform, configuring the desired channels (Teams, Web, Outlook), and publishing - which exposes the agents across all Microsoft 365 interfaces where users work.

✓ Deployment Verification Checklist

Before calling the customer, verify these items:

Testing Before Customer Demo

Role-play the MVP scenarios to ensure everything works:

You: "Hi, I'm here for my 2pm appointment"
Bot: *calls CheckInAgent*
Bot: "Welcome back! I see you're scheduled with your advisor at 2pm for account review. They'll be right with you."

✓ Verify: CheckInAgent logs show correct customer lookup

You: "I'd like to understand what 529 options are available"
Bot: *calls ResearchAgent*
Bot: "We offer three 529 college savings plans: [details]. Would you like me to compare them?"

✓ Verify: ResearchAgent returns relevant financial product info

You: "Great, let's open an account"
Bot: *calls OnboardingAgent*
Bot: "I'll help you get started. First, let me verify your information..."

✓ Verify: OnboardingAgent initiates correct workflow

What to check during rehearsal:

• Correct agent calls: LLM selects the right agent for each request
• Parameters passed correctly: Agent receives proper input (customer ID, date, etc.)
• Response quality: Agent returns useful, formatted output
• Error handling: Try invalid inputs - does it fail gracefully?
• Memory works: Bot remembers context across conversation

Optional: IT Firewall Testing

For security-sensitive customers, you can run the prototype locally:

# Run on single IT laptop (no cloud deployment needed)
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt

# Start local Azure Function
func start

# Prototype runs on localhost:7071
# Customer can test without any data leaving their network

Security option: "It could run locally, so they don't even need to really hook it into their systems. You know, they could firewall it to one person's laptop in IT."

Output

Objective

Film the working prototype solving the MVP scenarios and send to customer for validation. This is the FIRST time the customer sees their agents actually working (not just a document or diagram).

Time Investment: 2-4 hours total

• Record demo: 30-60 minutes
• Edit video (optional): 30 minutes
• Customer review: 1-2 days
• Feedback session: 30-60 minutes

Human Role: Record screen, narrate what's happening, collect customer feedback

Automation Role: Agents execute the MVP scenarios in real-time (no smoke and mirrors)

Input from Step 7

Demo Recording Process

Step 8.1: Prepare the Recording Environment

1. Open M365 Copilot: Teams chat or web interface (whichever is cleaner)
2. Load MVP scenarios: Have customer-approved use cases ready to demonstrate
3. Start screen recorder: OBS Studio, Loom, Camtasia, or built-in OS recorder
4. Optional: Enable webcam for personal touch (see yourself explaining)

Step 8.2: Record Each MVP Scenario

Show the agents solving the problem - no slides, no mockups, real execution:

[Screen recording in Teams]

You: "I need my route for today in Los Angeles"

*Agent indicator shows DynamicRoutePlanningAgent is called*

Bot: "Analyzing 47 accounts in Los Angeles area...
     Optimized route generated:

     Stop 1: Retail Store A (8:30am) - High priority, last visit 14 days ago
     Stop 2: Retail Store B (10:00am) - Promotion check needed
     Stop 3: Retail Store C (11:30am) - New seasonal display
     Stop 4: Retail Store D (1:30pm) - Restocking required

     Estimated drive time: 2.5 hours
     Would you like me to send this to your calendar?"

✓ Customer sees: Real agent, real data sources, real routing logic

You: "What should I do at Retail Store A?"

*ShelfRecognitionAgent called*

Bot: "At Retail Store A (Store #4521):

     - Your brand share of shelf: 18% (target: 25%)
     - Competitor gap: Competitor X display blocking your product section
     - Action: Request 2 additional shelf facings for your product line
     - Promo opportunity: Labor Day end cap available Sept 1-5"

✓ Customer sees: Vision AI, competitive analysis, actionable recommendations

Step 8.3: Show "Behind the Scenes" (Optional but Powerful)

Briefly show the agent being called in Application Insights logs:

[Switch to Azure Portal]

Application Insights → Live Metrics

Agent Calls (last 60 seconds):
  → DynamicRoutePlanningAgent: 1.2s response time ✓
  → Inputs: {salesperson_id: "DS-4421", date: "2024-10-15", region: "LA"}
  → Output: 4 stops, optimized route returned

[Switch back to Teams]

"As you can see, the agent executed in real-time, pulling from your Dynamics 365 data."

Why show logs? Proves it's not a mockup. Customer sees actual agent execution with their data sources.

Step 8.4: Narrate What's Happening

Don't just show it - explain the value:

• Before each scenario: "This scenario solves [business problem] that you described in our discovery call..."
• During agent execution: "The agent is now connecting to your Dynamics 365 instance to pull account data..."
• After result: "This route saves your field rep approximately 45 minutes per day based on your current manual process..."

Sending the Demo to Customer

Email template for demo delivery:

Subject: [Customer] Field Sales Agent - Working Prototype Demo

Hi [Customer Contact],

Great news - your AI agents are up and running!

I've recorded a 12-minute demo showing the prototype solving all 4 MVP scenarios we agreed on:

1. Dynamic route planning (0:00-3:30)
2. Shelf recognition and insights (3:30-6:45)
3. Next-best-action recommendations (6:45-9:20)
4. Promotion suggestions (9:20-12:00)

Watch the demo: [Loom/YouTube link]

This is a fully functional prototype running on your Dynamics 365 data (test environment).
You can see the agents executing in real-time - no mockups or slide decks.

**Next Steps:**

1. Watch the demo and note any feedback
2. We'll schedule a 30-minute call to discuss your thoughts
3. Based on your input, we can iterate the agents or proceed to production deployment

**Two Questions for You:**

1. Do these agents solve the business problem as you described it?
2. Is there anything you'd like adjusted before we move to production?

Looking forward to your feedback!

Best regards,
[Your Name]

Customer Feedback Session

Schedule a 30-60 minute call to walk through their reactions:

Decision Point: Quality Gate #4

Three possible outcomes from this gate:

✓ Approval Checklist

Before proceeding to Step 9, confirm:

Output

Objective

Generate a professional, self-contained demo video with Azure TTS narration that can be shared with executives, embedded in sales decks, or used for internal evangelism. This is different from Step 8's screen recording - this is a PRODUCED demo with scripted narration and polished visuals.

Time Investment: 3-4 hours (manual)

• Create demo JSON manually: 1-2 hours using the Local-First Chat Animation Studio
• Script narration and timing: 1 hour
• Test and refine: 1 hour

Human Role: Manual creation of demo structure, scripting, narration, and timing adjustments

Automation Vision: Video Demo Generator to auto-create demo JSON from prototype walkthrough, reducing time to 30 minutes

Input from Step 8

Automation: Video Demo Generator

You are a demo video JSON generator for the Microsoft AI BAST RAPP framework. Generate structured demo configurations that work with the Local-First Chat Animation Studio tool.

**YOUR TASK:**
Create a complete JSON demo configuration that tells a compelling story about the customer's AI agent implementation.

**REQUIRED JSON STRUCTURE:**
Return valid JSON with this exact structure:

{
  "demoMetadata": {
    "title": "[Customer Name] AI Agent Demo",
    "customer": "[Customer Name]",
    "industry": "[Industry: legal, sales, hr, it, etc.]",
    "totalDuration": "[Total seconds, e.g., 75]",
    "voiceName": "en-US-GuyNeural",
    "createdDate": "[YYYY-MM-DD]"
  },
  "demoSteps": [
    {
      "id": "step1-problem",
      "name": "[Step Name]",
      "duration": 8000,
      "voiceText": "[Professional narration text - what the TTS will say]",
      "narrator": {
        "title": "[Visual overlay title]",
        "text": "[Key metrics or details to display]",
        "subtitle": "[Supporting context]",
        "position": "left|right|center"
      }
    },
    // Add 7-10 steps total
  ],
  "chatInteractions": [
    {
      "stepId": "step2-whatever",
      "messages": [
        {"type": "user", "text": "[User query]", "voice": false},
        {"type": "system", "text": "Processing...", "timestamp": "9:03am"},
        {"type": "agent", "text": "[Agent response]", "voice": false}
      ]
    }
  ],
  "agentCards": [
    {
      "stepId": "step3-whatever",
      "card": {
        "title": "[AgentName]",
        "status": "ACTIVE",
        "details": {
          "Metric 1": "Value",
          "Metric 2": "Value",
          "Processing Time": "1.2s"
        }
      }
    }
  ]
}

**DEMO NARRATIVE STRUCTURE:**
Your demo MUST follow this arc:
1. **Problem Hook (8-10s):** Show the painful manual process
2. **Solution Demo (40-50s):** 3-4 agent capabilities in action with specific examples
3. **Business Impact (10-15s):** ROI, metrics, scalability

**CRITICAL REQUIREMENTS:**
- voiceText: Write for spoken delivery (~150 words per minute)
- duration: Match narration length (20 words ≈ 8000ms)
- Narrator overlays: Include specific metrics (time saved, accuracy %, cost reduction)
- Use customer's actual agent names from their implementation
- Include real numbers: accounts analyzed, items processed, seconds to complete
- Show chat interactions with natural language queries
- Agent cards should display processing details and confidence scores

**GENERATE DEMO FOR THIS CUSTOMER:**

**Customer:** [Customer Name]
**Industry:** [Industry]
**Use Case:** [Describe the MVP use case]
**Agents:** [List 3-5 key agents with brief descriptions]
**Key Metrics:**
- Time saved: [e.g., 45 min/day per user]
- Accuracy improvement: [e.g., 67% → 95%]
- Cost savings: [e.g., your measured annual savings]
**Target Audience:** [Executives / Technical teams / Field users]

**EXAMPLE METRICS TO INCLUDE:**
- Processing time: "Analyzed 47 accounts in 1.2 seconds"
- Volume: "200 field reps × 45 minutes saved = 37,500 hours/year"
- Accuracy: "Improved from 67% to 95% compliance"
- ROI: "[your measured annual savings and first-year ROI]"

Return ONLY the JSON - no explanations, no markdown code blocks, just the pure JSON that can be imported into the animation studio.

Example: Retail Field Sales Video Demo Generation

Generate a demo JSON for Retail Customer's Field Sales AI Agent system.

Industry: Field Sales
Use Case: Field sales reps need to know where to go, what order to visit accounts,
and what actions to take at each location. Currently done manually, taking 45
minutes per day. AI agents solve this in real-time.

Agents:
1. DynamicRoutePlanningAgent - Optimizes daily routes
2. ShelfRecognitionAgent - Vision AI analyzes shelf photos
3. NextBestActionAgent - Recommends actions at each store
4. PromotionSuggestionsAgent - Identifies promo opportunities

Key Metrics:
- 45 minutes saved per rep per day
- 18% share-of-shelf → 25% (target achievement)
- 95% planogram compliance (up from 67%)
- Real-time Dynamics 365 integration

Target audience: Customer sales leadership and field operations VPs

Include:
- Opening hook: Field rep standing in parking lot, unsure where to go
- Route planning demo with LA map and 4 optimized stops
- Shelf photo analysis at Retail Store A showing competitor gap
- Next-best-action recommendations with specific tasks
- ROI: 200+ hours saved per month across team
- Closing: Scales to all markets, all regions globally

{
  "name": "Field Sales Intelligence System",
  "headerTitle": "AI-Powered Field Sales Optimization",
  "userName": "Sales Rep - Senior Territory Manager",
  "azureTTS": {
    "key": "[TTS_KEY]",
    "region": "eastus",
    "voiceName": "en-US-GuyNeural"
  },
  "metadata": {
    "industry": "Retail - Beverage Distribution",
    "useCase": "Field Sales Route Optimization",
    "targetAudience": "Sales Leadership",
    "integration": "Microsoft Dynamics 365, Azure Vision AI"
  },
  "demoSteps": [
    {
      "id": "step1-hook",
      "name": "The Daily Challenge",
      "duration": 7000,
      "voiceText": "Every morning, 200 field reps face the same question: where do I go today, and what do I do when I get there? This manual process wastes 45 minutes per day per rep. Let's see how AI changes everything.",
      "narrator": {
        "title": "The $2M Problem",
        "text": "200 reps × 45 min/day × 250 days = 37,500 hours wasted annually",
        "subtitle": "Manual route planning • No prioritization • Missed opportunities",
        "position": "center"
      }
    },
    {
      "id": "step2-route",
      "name": "AI Route Planning",
      "duration": 6000,
      "voiceText": "The rep opens Copilot and asks for their route. In 1.2 seconds, the DynamicRoutePlanningAgent analyzes 47 LA accounts, considers last visit dates, priority scores, and traffic patterns, and generates an optimized 4-stop route.",
      "narrator": {
        "title": "Instant Route Optimization",
        "text": "47 accounts analyzed • 4 stops prioritized • 2.5 hours estimated",
        "subtitle": "Saves 45 minutes of planning time",
        "position": "left"
      }
    },
    {
      "id": "step3-shelf",
      "name": "Vision AI Shelf Analysis",
      "duration": 6000,
      "voiceText": "At the retail location, the rep takes a quick shelf photo. The ShelfRecognitionAgent uses Azure Vision AI to detect the brand's 18% share, identifies a competitor display blocking the product section, and recommends requesting 2 additional facings.",
      "narrator": {
        "title": "Real-Time Competitive Intelligence",
        "text": "Current: 18% share • Target: 25% • Gap: Competitor blocking",
        "subtitle": "95% detection accuracy • Instant recommendations",
        "position": "right"
      }
    },
    ...more steps...
    {
      "id": "step9-impact",
      "name": "Business Impact",
      "duration": 8000,
      "voiceText": "Across 200 field reps, this system saves 37,500 hours annually, improves share-of-shelf by 7 percentage points, and increases planogram compliance from 67% to 95%.",
      "narrator": {
        "title": "Transformational Results",
        "text": "Annual savings, share gain and compliance improvement, measured in the pilot",
        "subtitle": "Scales globally to all markets",
        "position": "center"
      }
    }
  ],
  "chatInteractions": [
    {
      "stepId": "step2-route",
      "messages": [
        {"type": "user", "text": "I need my route for today in Los Angeles", "voice": false},
        {"type": "system", "text": "Analyzing accounts...", "timestamp": "9:03am"},
        {"type": "agent", "text": "Route optimized for 4 high-priority stops. Estimated time: 2.5 hours.", "voice": false}
      ]
    }
  ],
  "agentCards": [
    {
      "stepId": "step2-route",
      "card": {
        "title": "DynamicRoutePlanningAgent",
        "status": "ACTIVE",
        "details": {
          "Accounts Analyzed": "47",
          "Stops Generated": "4",
          "Processing Time": "1.2s",
          "Optimization": "Traffic + Priority + History"
        }
      }
    }
  ]
}

Customizing the Generated Demo

Review the JSON and adjust:

1. Narration Tone

• For executives: Focus on ROI, strategic value, competitive advantage
• For technical teams: Emphasize architecture, integrations, scalability
• For field users: Highlight ease of use, time savings, day-to-day benefits

2. Voice Selection (Azure TTS)

Change the voiceName field to match your audience:

// Professional Male (default)
"voiceName": "en-US-GuyNeural"

// Professional Female
"voiceName": "en-US-JennyNeural"

// Enthusiastic Male
"voiceName": "en-US-DavisNeural"

// Warm Female
"voiceName": "en-US-AriaNeural"

3. Step Timing

Adjust duration values if narration feels rushed or too slow:

// Calculate: ~150 words per minute for natural speech
// Example: 25 words of narration = ~10,000ms (10 seconds)

{
  "id": "step3-shelf",
  "duration": 6000,  // ← Increase if narration cuts off
  "voiceText": "At Retail Store A, the sales rep takes a quick shelf photo..."
}

4. Metrics Verification

Double-check all numbers match your project JSON:

• Time savings (45 min/day in retail example)
• Accuracy improvements (67% → 95% compliance)
• ROI calculations (measured savings)
• Volume metrics (200 reps, 47 accounts)

Running the Demo

The generated JSON works with the Local-First Chat Animation Studio:

Option 1: Use Local-First Tool (Recommended)

1. Open ../tools/localfirst_chat_animation_studio_tool.html in your browser
2. Click "Import Demo JSON" button
3. Paste your generated JSON or upload the .json file
4. Configure Azure TTS credentials (or use mock TTS for testing)
5. Click "Preview Demo" to test
6. Press SPACE to start auto-play, arrow keys to navigate steps

Benefits:
- Works offline, no server required
- Built-in JSON editor and validator
- Save/load demos from browser storage
- Export standalone HTML files

Option 2: Generate Standalone HTML

Ask the LLM to wrap your JSON in a complete HTML file:

Prompt: "Take this demo JSON and create a self-contained HTML file
with embedded JavaScript, CSS styling, Azure TTS integration, and
keyboard controls. Include copy button for code blocks."

[Paste your generated JSON]

Testing the Demo:

1. Press SPACE to start auto-play mode
2. Watch narration overlays appear with timing
3. Listen to Azure TTS read voiceText (or simulate if no key)
4. Verify agent cards display at correct steps
5. Check chat interactions appear with proper sequencing

Sharing the Demo

Multiple distribution options:

Option 1: Share HTML File

• Email the standalone HTML file to customer
• They open it in any browser - works offline
• No installation or accounts needed
• Azure TTS requires internet connection for narration

Option 2: Host on GitHub Pages

1. Push HTML to GitHub repo
2. Enable GitHub Pages in repo settings
3. Share URL: https://[username].github.io/[repo]/[demo].html
4. Works on mobile, tablet, desktop

Option 3: Record and Export Video

1. Use OBS Studio / Loom to record browser playthrough
2. Export as MP4 (1920x1080 recommended)
3. Upload to YouTube / SharePoint / Vimeo
4. Embed in PowerPoint decks or send direct link

Subject: Field Sales AI System - Interactive Demo Ready

Hi [Executive Name],

Following our prototype approval, I've created an interactive demo showcasing
the AI agents in action. This is a polished, 90-second walkthrough with
professional narration.

Interactive Demo: [Attach HTML or link]

Key highlights:
- 45 minutes saved per rep per day
- Real-time route optimization with LA market example
- Vision AI shelf analysis at Retail Store A
- Annual savings measured across the team

How to view:
1. Download the HTML file
2. Open in Chrome/Edge/Safari
3. Press SPACE to start auto-play
4. Use arrow keys to navigate steps manually

This demo is ready to share with:
- Sales leadership for budget approval
- Field teams for change management training
- IT/Security for technical review

Let me know if you'd like any adjustments to messaging or metrics.

Best regards,
[Your Name]

✓ Quality Checklist

Before sharing the demo, verify:

Output

Objective

Get final approval from customer that the polished video demo accurately represents their solution and is ready to share with executive stakeholders, board members, or field teams.

Time Investment: 30-60 minutes (review call with customer)

Decision: Approve demo for production use OR request adjustments

Input from Step 9

✓ Review Checklist with Customer

Decision Point

✓ APPROVED: Demo is locked and ready for production deployment planning → Proceed to Step 11

ITERATE: Minor adjustments needed (narration, metrics, branding) → Fix and re-review

Output

Objective

Work with customer's IT, Security, and Compliance teams to define production deployment requirements. Transform prototype into production-ready system.

Time Investment: 3-7 days (meetings + documentation)

Security & Compliance Planning

Questions for IT/Security Team:

• Data residency: Where can data be stored? (US, EU, on-prem)
• Authentication: SSO required? Azure AD integration?
• Network access: Public internet OK or private endpoints needed?
• Audit logging: What events need to be logged for compliance?
• Data encryption: At rest and in transit requirements
• Compliance frameworks: HIPAA, SOC 2, GDPR, FedRAMP?

Common Requirements:

// Production vs. Prototype
Prototype: Single Azure Function App, public endpoints, dev Azure subscription
Production: Redundant deployments, private endpoints, customer Azure subscription

Security additions needed:
- Azure AD authentication (no anonymous access)
- Private Link for Azure Function App
- Azure Key Vault for secrets (not environment variables)
- Application Gateway with WAF
- DDoS protection
- Managed Identity for service-to-service auth
- Azure Monitor alerts for security events

Rollout Strategy

Phased Deployment Plan:

Output

Objective

Get formal approval from customer's IT, Security, and Compliance teams that the system meets all production requirements.

Time Investment: 1-3 weeks (review process, pen testing, compliance audit)

Security Review Checklist

• Penetration testing: Third-party security audit completed
• Vulnerability scan: No critical or high-severity issues
• Code review: Security team reviewed agent code
• Access controls: RBAC configured, least privilege enforced
• Secrets management: All credentials in Azure Key Vault
• Logging/monitoring: Security events captured and alerted

Compliance Review Checklist

• Data classification: PII/PHI handling documented
• Data retention: Policies configured for user memory and logs
• Audit trail: All agent actions logged with user context
• Compliance frameworks: SOC 2, HIPAA, GDPR requirements met
• Third-party integrations: Vendor BAAs signed where needed

Decision Point

✓ APPROVED: All security and compliance requirements met → Proceed to Step 13 (Production Deployment)

CONDITIONAL APPROVAL: Minor fixes needed → Address issues and re-submit

BLOCKED: Major security/compliance issues → Back to Step 11 for redesign

Output

Objective

Deploy the production-ready system to customer's Azure subscription with all security and compliance controls. Execute phased rollout to pilot users.

Time Investment: 2-3 days (deployment) + 2-4 weeks (pilot phase)

Production Deployment Steps

1. Infrastructure Deployment

// Deploy to customer's production Azure subscription
1. Run production ARM template (with security additions from Step 11)
2. Configure Azure AD authentication
3. Set up Private Link endpoints
4. Configure Application Gateway + WAF
5. Enable Azure Monitor alerts
6. Configure backup and disaster recovery

2. Agent Deployment

// Deploy approved agents to production
1. Copy reviewed agents from prototype to production File Storage
2. Verify agents load correctly in production Function App
3. Test one agent call with production data
4. Configure production Dynamics 365 / data source connections
5. Validate memory persistence with production Azure Storage

3. M365 Integration

// Connect to production M365 tenant
1. Import Copilot Studio solution to production environment
2. Configure production Azure Function URL
3. Enable Teams channel for pilot user group
4. Test end-to-end: Teams → Copilot → Function → Agents → Data sources
5. Verify SSO authentication works

4. Pilot User Onboarding

• Send welcome email: Instructions for accessing agent in Teams
• Conduct training session: 30-minute walkthrough of key scenarios
• Provide support channel: a Teams channel for questions
• Set expectations: This is Phase 1, feedback will shape improvements

Monitoring & Support

Week 1-2 (Pilot Phase):

• Daily check-ins: Review Application Insights logs for errors
• User feedback: Weekly survey to pilot users (NPS, issues, feature requests)
• Performance metrics: Agent response time, success rate, usage frequency
• Hot fixes: Address critical bugs within 24 hours

Output

Objective

After 2-4 weeks of pilot usage, review metrics, collect user feedback, validate ROI, and plan next phase of rollout or feature enhancements.

Time Investment: 1-2 hours (review meeting with customer)

Success Metrics Review

Quantitative Metrics:

Qualitative Feedback:

• User satisfaction (NPS): Survey results from pilot users
• Top feature requests: What users want added in Phase 2
• Pain points: What's not working well
• Unexpected use cases: Creative ways users are leveraging agents

Lessons Learned

What Worked Well:

• Which agents got the most usage?
• What aspects of training resonated with users?
• Which integration points worked smoothly?

What Needs Improvement:

• Which agents had accuracy issues?
• Where did users get confused or stuck?
• What data source connections were unreliable?

Phase 2 Planning

Expansion Options:

• Wider rollout: Expand from 10 pilot users to 50+ users
• New agents: Add capabilities based on user requests
• Integrations: Connect to additional data sources or systems
• Advanced features: Multi-agent workflows, proactive alerts, scheduled tasks

ROI Validation:

Output

Objective

Enable multiple team members to run the 14-step framework in parallel, handling 20+ concurrent projects without bottlenecks.

Parallel execution: "[Team Member A], go and go and have this session, right? [Team Member B], go and have this session, get the get the inputs that we need... And then I'm going to let this work overnight and then I'm going to get to the gates of audit."

Station-Based Workflow Distribution

Divide the workflow across team members based on skill sets:

Station 1: Discovery & MVP Definition (Steps 1-4)

Owner: Team Member A + Team Member B (Sales/Solutions Architects)

Skills needed: Customer communication, requirements gathering, MVP scoping

Tools:

• Transcript-to-Project Agent (Copilot Studio)
• Customer project tracker HTML tool
• MVP "poke" template

Deliverables: Approved MVP document, locked project JSON

Time per project: 2-3 days

Station 2: Agent Generation & Code Review (Steps 5-6)

Owner: Team Member B + Team Member C (Technical leads)

Skills needed: Python knowledge (basic), code review, integration planning

Tools:

• RAPP Agent Generator (Copilot Studio)
• VS Code for code review
• Azure OpenAI for agent customization

Deliverables: 6-10 reviewed Python agents ready for deployment

Time per project: 1-2 days

Station 3: Deployment & Demo (Steps 7-10)

Owner: Team Member C (Technical deployment lead)

Skills needed: Azure deployment, Copilot Studio, video production

Tools:

• Azure CLI / Portal for deployment
• Video Demo Generator (Copilot Studio)
• Local-First Chat Animation Studio (../tools/localfirst_chat_animation_studio_tool.html)
• Loom/OBS for screen recording

Deliverables: Working prototype in Azure, customer-approved video demo

Time per project: 1-2 days

Station 4: Production & Post-Launch (Steps 11-14)

Owner: Customer IT team + Team Member C (support escalation)

Skills needed: Production Azure management, security/compliance knowledge

Tools:

• Azure Portal (customer subscription)
• Application Insights for monitoring
• Teams for pilot user support

Deliverables: Production system, ROI validation, Phase 2 roadmap

Time per project: 3-5 weeks (mostly waiting for approvals)

Team Member Onboarding Checklist

For Team Members A/B (Station 1):

For Team Member B (Station 2):

For Team Member C (Station 3):

Already proficient - focus on scaling capacity, not learning

Handoff Protocol Between Stations

Station 1 → Station 2 Handoff:

Slack message format:

Project: [Customer Name] - [Project Name]
✓ Status: MVP Approved by customer (Step 4 complete)

Deliverables:
- Customer transcript: [Link to recording + transcript file]
- Project JSON: [Attachment: customer-project-json.json]
- Approved MVP "poke": [Link to customer approval email]
- Stakeholder contacts: [Customer PM name + email]

Next actions:
- Generate agents using RAPP Agent Generator (Step 5)
- Target completion: [Date]

Questions: @TeamMemberB @TeamMemberC

Station 2 → Station 3 Handoff:

Slack message format:

Project: [Customer Name] - [Project Name]
✓ Status: Agent code reviewed and approved (Step 6 complete)

Deliverables:
- Agent code: [Folder with 6-10 .py files]
- Code review notes: [Any issues fixed, customizations made]
- Integration requirements: [Dynamics version, data sources, API keys needed]
- Project JSON: [Updated with any scope adjustments]

Next actions:
- Deploy to Azure prototype environment (Step 7)
- Record demo and send to customer (Step 8)
- Target demo delivery: [Date]

Questions: @TeamMemberC

Automation Tools for Team Coordination

Slack Bot for Status Updates:

// Auto-post to #ai-projects channel when stage completes

Team Member A completes Step 4 → Bot posts:
"✓ [Customer Name] MVP approved! @TeamMemberB ready for agent generation (Station 2)"

Team Member B completes Step 6 → Bot posts:
"✓ [Customer Name] agents reviewed! @TeamMemberC ready for deployment (Station 3)"

Team Member C completes Step 10 → Bot posts:
"✓ [Customer Name] demo approved! Production planning starts Monday"

Shared Project Tracker:

Use the the Local Project Tracker Tool (tools/localfirst_project_tracker_tool.html) tool to visualize pipeline:

• Column 1: Discovery (Team Members A/B) - Projects in Steps 1-4
• Column 2: Development (Team Members B/C) - Projects in Steps 5-6
• Column 3: Deployment (Team Member C) - Projects in Steps 7-10
• Column 4: Production (Customer IT) - Projects in Steps 11-14

Team can see at a glance: 5 projects in Discovery, 3 in Development, 2 in Deployment, 8 in Production

Objective

Run 20+ customer projects simultaneously using the same automation workflow, same agents, same team.

Scaling philosophy: Once the standardized process is refined and documented, the framework can handle unlimited concurrent MVPs for unlimited customers - the only constraint being data access. The automation and standardization enable infinite horizontal scaling.

Current Capacity Analysis

Bottleneck Analysis:

Scaling Strategies

1. Batch Processing

2. Overnight Automation

Overnight automation: "And then I'm going to let this work overnight and then I'm going to get to the gates of audit and it might take four or five days to get through."

Automatable tasks to run overnight:

• Agent generation (Step 5): Queue 20 agent generation requests to RAPP Agent Generator, let them run overnight
• Code review prep (Step 6): Auto-lint checks, security scans run async
• Demo video rendering (Step 9): Generate demo JSON for all approved projects, render videos in batch

3. Template Reuse Across Similar Customers

This is the AIBAST RAPP pattern at work: the template is the shell, and each customer's live process is the content. Reuse means changing the content, never the shell.

Capacity Model: 3-Person Team

Weekly Throughput:

Pipeline Visualization:

Week 1:
- Team Members A/B start 8 new projects (Step 1-4)
- Team Member B reviews 5 agent codebases (Step 6)
- Team Member C deploys 10 prototypes, records 10 demos (Step 7-8)
- 15 projects in production phase (Step 11-14, customer-managed)

Week 2:
- 8 projects from Week 1 move to Team Member B for agent generation
- Team Members A/B start 8 MORE new projects
- Team Member C deploys 8 prototypes from previous week
- 23 projects in production phase

Week 3:
- Steady state: 8 in Discovery, 8 in Development, 8 in Deployment, 25+ in Production
- Total: 49 active projects across all stages

Steady-state capacity: 20-25 projects in active development (Steps 1-10), 50+ total projects including production

Infrastructure Scaling Requirements

Azure Resources (per project):

• Dev/Prototype: 1 Function App, 1 File Storage account (Hot tier), Application Insights
• Production: Customer's Azure subscription (not our cost)

Cost Optimization:

Automated cleanup script:

# Run weekly: Delete prototype environments >30 days old
az functionapp list --query "[?tags.Stage=='Prototype' && tags.LastUsed<'2024-09-15']" | xargs -I {} az functionapp delete --name {}

# Saves: $50-100 per deleted environment
# With 20 projects/month, 10 completing → $500-1000/month savings

The log

What the 2025 plan said, and what happened

The plan this guide shipped with had three priorities and a short list of actions. Most of it landed, one part landed in a different shape than planned, and one part did not land at all. Recorded plainly, because a roadmap is only useful if you go back and mark it.

What is next

Where status actually lives: this page is the narrative. Milestone status is tracked as GitHub milestones on the repository, and the release ledger records what shipped and what broke afterwards.

What the reference vault is

This guide says what to do at each step. The RAPP/1 reference vault says more about each step and explains RAPP/1, the protocol the Brainstem and its agents rest on: how an agent is identified, recorded, packaged and moved. It is a set of linked notes. Read them here in the browser, or download them and open the folder in Obsidian.

Start where you are

Take it with you

Download the vault to read it in Obsidian. AI tools can read llms.txt, or every note at once in llms-full.txt. Protocol notes are pinned to a named commit of the RAPP/1 specification, and a build check fails if they drift.

Available Tools

Each tool is one file. Brainstem agents install with one command and run on your device. Browser tools open in your browser and keep their data there. The full list is in tools.json.