Strategic Framework

Deeployd's Strategic Framework enables organizational alignment for hybrid Human+Agent teams. It ensures that every team and agent operates in sync with your company's strategic direction.

Overview

The framework consists of four interconnected components:

┌─────────────────────────────────────────────────────────────────────┐
│                    STRATEGIC ALIGNMENT                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌──────────────┐                                                   │
│  │ APP DIRECTION│  Leadership sets strategic direction             │
│  │ (North Star) │  Priorities, Strategies, Guardrails, Signals     │
│  └──────┬───────┘                                                   │
│         │                                                           │
│         ▼  BROADCASTS cascade down                                  │
│  ┌──────────────┐                                                   │
│  │  STRATEGIC   │  "Priority shift: retention over acquisition"    │
│  │  BROADCAST   │  "New competitor entered market"                 │
│  └──────┬───────┘                                                   │
│         │                                                           │
│         ▼  Teams/Agents analyze impact                              │
│  ┌──────────────┐                                                   │
│  │  RESPONSES   │  "I'm affected, proposing charter update"        │
│  │  & ACTIONS   │  "Submitting staffing request"                   │
│  └──────────────┘                                                   │
│                                                                     │
│  ◄──────────── SELF-CLEANING alerts flow up ────────────────────►  │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

App Direction

App Direction is Deeployd's native strategic alignment framework, inspired by V2MOM but designed for hybrid Human+Agent teams.

The 5 Elements

Element	Purpose	Example
North Star	Where are we going? One clear sentence.	"Become the most trusted AI platform for enterprise teams"
Priorities	What matters most RIGHT NOW? Forces trade-offs.	1. Customer retention 2. Enterprise security 3. Speed to value
Strategies	How do we get there? Actionable approaches.	"Focus on onboarding experience", "SOC2 by Q2"
Guardrails	What we WON'T do. Boundaries for humans AND agents.	"No discounts below 20%", "Always escalate legal issues"
Signals	How do we know we're winning? Measurable indicators.	"NRR > 120%", "Time to value < 7 days"

Why Not V2MOM?

V2MOM (Vision, Values, Methods, Obstacles, Measures) is powerful for human organizations, but Deeployd needed something tailored for hybrid teams:

V2MOM	App Direction	Why the change
Values	Priorities	Agents need ranked priorities for trade-off decisions
Obstacles	Guardrails	Reframed as boundaries, not barriers
Methods	Strategies	More actionable, less abstract
Measures	Signals	Real-time indicators, not just targets

Creating an App Direction

// Create a new direction (starts as draft)
const direction = await strategyRepository.direction.create({
  appId: 'app_xyz123',
  northStar: 'Become the #1 AI platform for enterprise teams',
  priorities: [
    { rank: 1, area: 'Customer Retention', description: 'Reduce churn, increase NRR', weight: 40 },
    { rank: 2, area: 'Enterprise Security', description: 'SOC2, ISO27001', weight: 35 },
    { rank: 3, area: 'Speed to Value', description: 'Faster onboarding', weight: 25 },
  ],
  strategies: [
    { id: 'strat_1', title: 'Onboarding Overhaul', description: 'Reduce time to value from 14 days to 3 days' },
    { id: 'strat_2', title: 'SOC2 Certification', description: 'Complete SOC2 Type II by Q2' },
  ],
  guardrails: [
    { id: 'guard_1', rule: 'No discounts below 20% without VP approval', type: 'hard', appliesTo: 'all' },
    { id: 'guard_2', rule: 'Always escalate legal/compliance issues', type: 'hard', appliesTo: 'agents' },
  ],
  signals: [
    { id: 'sig_1', metric: 'Net Revenue Retention', target: '> 120%', current: 108 },
    { id: 'sig_2', metric: 'Time to Value', target: '< 7 days', current: 12 },
  ],
  createdBy: 'user_ceo123',
})

// Activate when ready (archives previous active direction)
await strategyRepository.direction.activate(direction.id, 'user_ceo123')

Strategic Broadcasts

When strategy changes, broadcasts cascade the news to all teams and agents.

Broadcast Types

Type	When to use
`direction_update`	App Direction changed
`priority_shift`	Priorities reordered
`new_guardrail`	New boundary added
`market_alert`	Market change detected
`competitor_move`	Competitor action
`crisis`	Urgent situation
`opportunity`	New opportunity identified
`policy_change`	Corporate policy updated
`org_change`	Organizational restructure

Urgency Levels

Level	Meaning	Expected Response
`info`	FYI, no action required	Acknowledge when convenient
`action_required`	Action needed	Respond within deadline
`critical`	Urgent action needed	Immediate response required

Creating a Broadcast

const broadcast = await strategyRepository.broadcast.create({
  appId: 'app_xyz123',
  type: 'priority_shift',
  title: 'Q2 Priority Change: Retention over Acquisition',
  summary: 'We are shifting focus from new customer acquisition to retaining existing customers.',
  details: `
    ## Context
    Our churn rate increased 15% last quarter. We need to stabilize before growing.

    ## What this means
    - Sales: Focus on expansion deals, not new logos
    - Support: Proactive outreach to at-risk accounts
    - Product: Ship retention features before new features

    ## Expected outcomes
    - Reduce churn from 5% to 2%
    - Increase NRR from 108% to 120%
  `,
  urgency: 'action_required',
  affectedTeams: 'all',
  requiresAcknowledgment: true,
  acknowledgmentDeadline: new Date(Date.now() + 48 * 60 * 60 * 1000), // 48 hours
  broadcastedBy: 'user_ceo123',
})

Agent Response to Broadcasts

When an agent receives a broadcast, it:

Analyzes impact - "Does this affect my mission?"
Assesses relevance - "How relevant is this to my work?" (0-100)
Takes action - Acknowledge, propose updates, or escalate

const response = await strategyRepository.broadcastResponse.create({
  broadcastId: broadcast.id,
  responderId: 'agent_sales_lead',
  responderType: 'agent',
  responderName: 'Sales Lead Agent',
  impact: {
    isAffected: true,
    relevance: 85,
    analysis: 'This significantly changes my targets. I need to shift from new logo acquisition to expansion and upsell.',
    affectedAreas: ['targets', 'outreach_strategy', 'success_metrics'],
  },
  action: {
    type: 'por_submitted',
    details: 'Submitted prompt optimization request to update my sales methodology and targets.',
    linkedPorId: 'por_xyz789',
  },
})

Staffing Requests

Agents can propose staffing changes to stay aligned with strategy. This includes creating new agents, terminating redundant ones, or reorganizing teams.

Request Types

Type	Description
`create_agent`	Hire a new agent
`terminate_agent`	Remove an agent
`terminate_team`	Dissolve an entire team
`merge_teams`	Combine two teams
`split_team`	Divide a team
`reassign_agent`	Move agent to different team

Self-Termination

Agents can propose their own termination when they become redundant. No ego, 100% optimal.

const request = await strategyRepository.staffingRequest.create({
  appId: 'app_xyz123',
  teamId: 'team_support',
  requestedBy: 'agent_tier1_support',
  type: 'terminate_agent',
  target: {
    agentId: 'agent_tier1_support', // Self-termination
  },
  rationale: {
    alignmentReason: 'The new AI Support Team now handles all tier-1 inquiries.',
    evidence: [
      'My task volume dropped from 150/week to 8/week',
      '95% of my previous tasks now routed to Support Team',
      'No unique capabilities remaining',
    ],
    impactAnalysis: 'Termination will save $500/month with no service degradation.',
    alternativesConsidered: ['Reassignment to Support Team (rejected: skills overlap)'],
  },
  efficiency: {
    currentCost: 500,
    projectedCost: 0,
    currentUtilization: 5,
    workloadAnalysis: 'Utilization dropped from 80% to 5% over 30 days',
  },
  isSelfTermination: true,
  approvalLevel: 'human', // Always requires human approval
})

Approval Flow

Agent/Boss proposes → Pending Approval → Human/Boss reviews → Approved/Rejected → Executed

Self-Cleaning Alerts

Deeployd continuously monitors for inefficiencies and generates cleaning alerts.

Detection Triggers

Trigger	Detection Logic
`low_utilization`	Agent < 10% utilized for 30 days
`redundancy_detected`	Two agents doing overlapping work
`strategy_drift`	Mission no longer aligns with App Direction
`consistent_failures`	> 50% task failure rate
`cost_value_mismatch`	Cost exceeds value delivered
`bottleneck_detected`	Agent causing workflow delays

Alert Lifecycle

Detected → Acknowledged → Action Taken (Staffing Request) or Dismissed

Example Alert

const alert = await strategyRepository.cleaningAlert.create({
  appId: 'app_xyz123',
  teamId: 'team_sales',
  agentId: 'agent_cold_outreach',
  triggerType: 'low_utilization',
  severity: 'medium',
  detection: {
    metric: 'utilization_rate',
    threshold: 10,
    actualValue: 3,
    period: 'last_30_days',
    analysis: 'Cold outreach tasks dropped after priority shift to retention.',
  },
  suggestedAction: {
    type: 'terminate_agent',
    description: 'Consider terminating Cold Outreach Agent and redistributing remaining tasks.',
    estimatedSavings: 300,
  },
})

API Reference

App Direction Endpoints

Method	Endpoint	Description
GET	`/api/apps/:appId/direction`	Get active direction
GET	`/api/apps/:appId/directions`	List all directions
POST	`/api/apps/:appId/directions`	Create new direction
PATCH	`/api/apps/:appId/directions/:id`	Update direction
POST	`/api/apps/:appId/directions/:id/activate`	Activate direction

Strategic Broadcast Endpoints

Method	Endpoint	Description
GET	`/api/apps/:appId/broadcasts`	List broadcasts
POST	`/api/apps/:appId/broadcasts`	Create broadcast
GET	`/api/apps/:appId/broadcasts/:id`	Get broadcast details
GET	`/api/apps/:appId/broadcasts/:id/responses`	Get responses
POST	`/api/apps/:appId/broadcasts/:id/respond`	Submit response

Staffing Request Endpoints

Method	Endpoint	Description
GET	`/api/apps/:appId/staffing-requests`	List requests
POST	`/api/apps/:appId/staffing-requests`	Create request
POST	`/api/apps/:appId/staffing-requests/:id/approve`	Approve request
POST	`/api/apps/:appId/staffing-requests/:id/reject`	Reject request
POST	`/api/apps/:appId/staffing-requests/:id/execute`	Execute approved request

Cleaning Alert Endpoints

Method	Endpoint	Description
GET	`/api/apps/:appId/cleaning-alerts`	List alerts
POST	`/api/apps/:appId/cleaning-alerts/:id/acknowledge`	Acknowledge alert
POST	`/api/apps/:appId/cleaning-alerts/:id/dismiss`	Dismiss alert
POST	`/api/apps/:appId/cleaning-alerts/:id/action`	Take action (create staffing request)

Best Practices

For Leadership

Keep the North Star stable - Change it only for major pivots
Update priorities quarterly - Regular cadence keeps teams aligned
Make guardrails explicit - Agents need clear boundaries
Use broadcasts for major changes - Don't let strategy drift silently

For Teams

Respond to broadcasts promptly - Delayed alignment = wasted effort
Propose changes, don't ignore drift - Submit PORs when misaligned
Trust the self-cleaning system - Redundancy is normal, handle it gracefully

For Agents

Check direction before major decisions - Stay aligned
Use priorities for trade-offs - When in doubt, check the weights
Respect guardrails absolutely - Hard limits are hard limits
Propose self-termination when appropriate - No ego, 100% optimal

Teams - Team structure and settings
Team Settings - Orchestration and behavior
Agent-to-Agent - A2A communication

Overview​

App Direction​

The 5 Elements​

Why Not V2MOM?​

Creating an App Direction​

Strategic Broadcasts​

Broadcast Types​

Urgency Levels​

Creating a Broadcast​

Agent Response to Broadcasts​

Staffing Requests​

Request Types​

Self-Termination​

Approval Flow​

Self-Cleaning Alerts​

Detection Triggers​

Alert Lifecycle​

Example Alert​

API Reference​

App Direction Endpoints​

Strategic Broadcast Endpoints​

Staffing Request Endpoints​

Cleaning Alert Endpoints​

Best Practices​

For Leadership​

For Teams​

For Agents​

Related​