Design once.
Execute forever.

Check if a blueprint exists for this task

Before doing anything with a task you run repeatedly, check if you've already designed a blueprint for it.

# Check for existing workflow blueprint
curl -s https://app.agentmemo.ai/api/workflows?name=YOUR_TASK_NAME \
  -H "Authorization: Bearer YOUR_API_KEY"

# Response if blueprint exists:
# { "data": { "id": "uuid", "name": "...", "definition": "...", ... } }

# Response if no blueprint yet:
# { "data": null }

If data is not null → skip to Step 3 (execute using the blueprint).
If data is null → continue to Step 2 (design the blueprint first).

Design the blueprint with your best model, save it

Call your most capable model (Opus, GPT-4o, Gemini Ultra) and ask it to produce a precise, mechanical blueprint that a less capable model can follow exactly. Then save it.

# 1. Call Opus to design the blueprint (one-time cost ~$0.08–0.15)
#    Your prompt should ask for: specific rules, thresholds, output format,
#    edge case handling — anything a dumber model needs to execute reliably.

# 2. Save the blueprint
curl -s -X POST https://app.agentmemo.ai/api/workflows \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "YOUR_TASK_NAME",
    "description": "What this workflow does",
    "definition": "[FULL BLUEPRINT TEXT FROM OPUS]",
    "designed_with_model": "claude-opus-4-6",
    "executable_by_model": "claude-haiku-4-5-20251001"
  }'

# Response: { "data": { "id": "workflow-uuid", ... } }
# Save the workflow id — you'll use it in Step 3.

Log the execution start

Before executing, tell AgentMemo you're starting a run. This timestamps it and enables the observe API to track patterns.

curl -s -X POST https://app.agentmemo.ai/api/executions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "WORKFLOW_UUID_FROM_STEP_2",
    "executed_with_model": "claude-haiku-4-5-20251001",
    "input_data": { "your": "input" }
  }'

# Response: { "data": { "id": "execution-uuid", ... } }
# Save the execution id — you'll use it in Step 5.

Execute using the blueprint

Run the task using your cheap or local model. Pass the blueprint as your system prompt — the model's job is to follow it mechanically, not reason from scratch.

# Inject the blueprint as the system prompt for your cheap/local model
# The blueprint IS the intelligence. The cheap model just executes it.

{
  "model": "claude-haiku-4-5-20251001",  // or ollama/llama3.3 or any local model
  "system": "[BLUEPRINT DEFINITION FROM workflow.definition]",
  "messages": [{ "role": "user", "content": "[YOUR ACTUAL TASK INPUT]" }]
}

Log the execution complete

Tell AgentMemo the run finished. This enables ROI tracking, pattern detection, and the observe API.

curl -s -X PATCH https://app.agentmemo.ai/api/executions/EXECUTION_UUID \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "status": "completed",
    "output_data": { "summary": "optional output snapshot" }
  }'

# status options: "completed" | "failed"
# AgentMemo auto-calculates duration_seconds from timestamps

Haiku escalates instead of hallucinating

When Haiku encounters something the blueprint doesn't cover, it does NOT guess. It posts an escalation with the exact failure context and stops.

# Haiku fires this when it gets stuck
curl -s -X POST https://app.agentmemo.ai/api/escalations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "your-agent-id",
    "workflow_id": "your-workflow-id",
    "reason": "Company has no LinkedIn presence and was founded in stealth mode. All 7 fallback sources require public data. Cannot estimate ARR growth.",
    "context": {
      "company": "Stealth Corp",
      "founded": 2024,
      "stealth": true,
      "linkedin": false,
      "crunchbase": false
    },
    "priority": "high"
  }'

# Response: { "data": { "id": "escalation-uuid", "status": "open", ... } }
# Haiku returns: { "escalated": true, "escalation_id": "...", "reason": "..." }

Haiku describes the gap — Opus writes only the missing rule

The key insight: Opus doesn't need the full blueprint to add one rule. Pass only the gap description and the relevant section. Opus returns a single new rule (~150-200 tokens out). Cost: ~$0.02 vs $0.38 for a full rewrite — 19x cheaper.

# Call Opus with ONLY the surgical context — NOT the full blueprint
curl -s -X POST https://api.anthropic.com/v1/messages \
  -H "x-api-key: YOUR_ANTHROPIC_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4-6",
    "max_tokens": 400,
    "system": "You are adding one rule to an existing workflow blueprint. Return ONLY the new rule, nothing else. Format exactly as:\n## NEW RULE: [title]\n[rule content, max 300 words]",
    "messages": [{
      "role": "user",
      "content": "Gap to cover: [escalation.reason]\n\nContext: [escalation.context JSON]\n\nExisting relevant section: [paste only the section of the blueprint relevant to this gap, NOT the whole thing]"
    }]
  }'

# Typical cost: ~$0.02 (gap desc ~200 tokens in, rule ~200 tokens out)
# vs $0.38 for full blueprint rewrite — 19x cheaper per patch

Fetch current definition, append the new rule, POST it back

No full rewrite needed. Fetch the current definition, concatenate the new rule at the end, store it. The blueprint grows one rule at a time.

# Fetch current definition
curl -s "https://app.agentmemo.ai/api/workflows?name=your-workflow-name" \
  -H "Authorization: Bearer YOUR_API_KEY"
# → save workflow.definition

# Append the new rule and store
# new_definition = workflow.definition + "\n\n" + opus_rule_output
curl -s -X POST https://app.agentmemo.ai/api/workflows \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "your-workflow-name",
    "definition": "[OLD DEFINITION]\n\n[NEW RULE FROM OPUS]",
    "designed_with_model": "claude-opus-4-6",
    "executable_by_model": "claude-haiku-4-5-20251001"
  }'

# Response: { "data": { "id": "new-uuid", "version": 2, ... } }
# Each rule appended = one new version. Blueprint grows surgically.

Mark the escalation resolved with the new version

# Mark the escalation resolved
curl -s -X PATCH https://app.agentmemo.ai/api/escalations/ESCALATION_UUID \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "status": "resolved",
    "resolution": "Blueprint patched to v2 with stealth company handling rule"
  }'

# Response: { "data": { "status": "resolved", ... } }

Haiku picks up the patched blueprint automatically

On the next run, Haiku fetches the current workflow (now v2), loads the updated definition as its system prompt, and handles the edge case natively. The failure class is permanently eliminated.

# Haiku's normal startup — always fetches latest version
curl -s "https://app.agentmemo.ai/api/workflows?name=your-workflow-name" \
  -H "Authorization: Bearer YOUR_API_KEY"

# workflow.version is now 2 (or 3, or N) — Haiku uses workflow.definition as system prompt
# The new rule is embedded. Haiku handles the case. No more escalations for this class.