Building Agentic Workflows for Strategic Execution

Strategic plans are notorious for failing not at the formulation stage, but in the execution. For decades, they have existed as static documents—PowerPoint decks and spreadsheets—reviewed quarterly, but disconnected from the daily torrent of operational data. Simple automation started bridging this gap, but it's only a reactive first step.

What if your strategy could do more than just be tracked? What if it could perceive performance, decide on a course of action, and proactively intervene to stay on track? This is the power of agentic workflows: intelligent, goal-oriented systems that turn your strategy into an active participant in your business.

With Plans.do, your strategic plan becomes the programmatic source of truth, the central nervous system for building these intelligent agents. Let's explore how to move beyond simple automation and create workflows that don't just report on the past, but actively shape the future of your execution.

From Simple Automation to Intelligent Agents

It's crucial to understand the leap we're making.

• Simple Automation is Reactive and Linear: It follows IF-THIS-THEN-THAT logic. "IF a deal is marked 'Closed-Won' in Salesforce, THEN update the 'Revenue' Key Result." This is useful for data collection but lacks context and decision-making power. It's a glorified data pipe.

• An Agentic Workflow is Proactive and Goal-Oriented: An "agent" is a system designed to achieve a specific goal. It perceives its environment, makes decisions based on its state relative to its goal, and takes complex actions to move closer to that goal.

In the context of strategy, this means an agent:

1. Perceives: It continuously ingests real-time data from your operational tools (CRMs, analytics, ad platforms).
2. Reasons: It analyzes this data against the strategic goal defined in Plans.do. It doesn't just see that a number changed; it understands if progress is on track, accelerating, or falling behind schedule.
3. Acts: Based on its reasoning, it initiates multi-step, contextual actions across different systems to course-correct, flag risks, or capitalize on opportunities.

Plans.do provides the "goal state." The plan you define in our API is the objective function the agent is built to solve.

The Building Blocks of a Strategic Agent

Creating an agentic workflow isn't about a single piece of software; it's about composing services around a central strategic truth. Plans.do is that truth.

Step 1: Define the Strategy as Code (The Goal)

Everything starts by codifying your plan. Static documents are ambiguous. Code is not. Using the Plans.do SDK, you create a structured, machine-readable version of your strategy. This becomes the agent's immutable charter.

import { plans } from 'do-sdk';

const marketingPlan = await plans.create({
  name: 'Q3 2025: Scale Customer Acquisition',
  owner: 'marketing@example.com',
  timeframe: {
    start: '2025-07-01',
    end: '2025-09-30'
  },
  objectives: [
    {
      objective: 'Increase qualified leads by 20%',
      keyResults: [
        { id: 'kr_1', name: 'Generate 5,000 MQLs', value: 0, target: 5000 },
        { id: 'kr_2', name: 'Achieve 15% MQL to SQL conversion', value: 0.11, target: 0.15 }
      ]
    },
    {
      objective: 'Reduce Customer Acquisition Cost (CAC) by 10%',
      keyResults: [
        { id: 'kr_3', name: 'Decrease cost-per-click to $2.50', value: 3.10, target: 2.50 }
      ]
    }
  ]
});

// The agent now has a clear, programmatic goal: marketingPlan.id
console.log(marketingPlan.id);
// plan_abc123xyz

Step 2: Build the Perception Layer (The Senses)

Your agent needs to "see" what's happening in the business. This involves creating small services or scripts that:

1. Poll Operational Systems: Fetch MQL data from your CRM API, CPC data from the Google Ads API, conversion data from your product analytics.
2. Update the Plan's State: Push this new data into Plans.do by updating the relevant Key Result.

// Example: A service that runs every hour
const currentCPC = await googleAds.getAverageCPC('q3-campaigns');
await plans.keyResults.update('kr_3', { value: currentCPC });

By centralizing state updates in Plans.do, you create a single, real-time picture of strategic performance, bridging the gap between strategy and operations.

Step 3: Implement the Decision Engine (The Brain)

This is where intelligence comes in. The decision engine is a service that continuously analyzes the plan's state and decides if action is needed.

1. Fetch the Current Plan: The engine regularly gets the full plan object from the Plans.do API.
2. Analyze Progress and Velocity: It does more than read the current value. It calculates the progress percentage (value / target), compares it to the time elapsed in the quarter, and determines the velocity. Is the plan on track?
3. Identify Risks: The engine's logic can identify negative trends. For example: if (keyResult.id === 'kr_3' && keyResult.value > keyResult.target) { ... }.
4. (Advanced) Leverage LLMs: For more nuanced reasoning, you can pass the plan's JSON object to a large language model.
   • Prompt: "Given the following strategic plan state, which Key Result is most at risk of failure and why? Suggest three concrete, actionable interventions. Plan: { ...planJSON }"
   • The LLM can provide sophisticated analysis and recommend actions that the agent can then execute.

Step 4: Create the Action Layer (The Hands)

Based on the decision engine's output, the agent takes action by calling other APIs. This is where the strategy becomes truly executable.

• Communication: Send a detailed, contextual alert to a Slack channel with a link to the Plans.do plan.
• Task Management: Create a high-priority task in Jira or Asana, automatically populating the description with data from the at-risk Key Result.
• System Intervention: Directly pause an underperforming ad campaign via its API.
• Human-in-the-loop: Trigger a workflow in a tool like Retool that presents the data and proposed actions to a human for approval.

Example: The "Marketing Performance Agent" in Action

Let's bring this to life with our plan_abc123xyz.

Imagine an agent running on a scheduler (e.g., every 30 minutes).

1. Perceive: The agent pulls the latest CPC from Google Ads, which has risen to $3.30. It updates kr_3 in Plans.do. It also pulls the MQL count from HubSpot, noting that the rate of new MQLs has slowed this week.

2. Reason: The agent fetches the full plan state.

   • It sees kr_3's value (3.30) is moving away from its target (2.50). This is a negative velocity.
   • It calculates that at the current MQL acquisition rate, kr_1 will miss its target of 5,000 by approximately 800.
   • Conclusion: The objective "Reduce CAC" is failing, which is now putting the "Increase qualified leads" objective at risk.

3. Act: The agent initiates a sequence of actions:

   • Action 1 (Slack): It posts to the #marketing-alerts channel:

     📈 Strategy Alert: 'Q3 2025: Scale Customer Acquisition'

     • Objective at Risk: Reduce CAC by 10%
     • Reason: Key Result Decrease cost-per-click to $2.50 is trending negatively.
       • Current: $3.30
       • Target: $2.50
     • Impact: MQL acquisition velocity has slowed. Forecasted to miss E-o-Q target.
     • Link to Plan: https://app.plans.do/plan/plan_abc123xyz

   • Action 2 (Jira): It calls the Jira API to create a task assigned to the marketing lead:

     Title: Investigate Rising CPC in Q3 Campaigns
     Description: CPC is at $3.30, against a target of $2.50 for KR 'kr_3'. This is impacting our ability to hit MQL targets for the quarter. Please analyze performance of top 5 ad groups.
     Linked Plan: plan_abc123xyz

   • Action 3 (Advanced): If configured for it, the agent could even identify the specific ad group with the highest cost and lowest conversion rate and automatically reduce its budget by 25%, logging this action for human review.

Your Strategy, Now an Active Participant

By treating your strategy as code with Plans.do, you unlock the ability to build these powerful agentic systems. Your plan transforms from a passive document into the active, intelligent core of your execution engine. It's no longer something you check; it's something that checks in on your business, 24/7.

This is the essence of Business-as-Code. Your company's strategy becomes a living, adaptable service that actively works to achieve its own objectives.

Ready to build? Explore the Plans.do API documentation and start turning your strategic goals into intelligent agents today.