{"slug":"business/OPERATOR_LOOP_DOCTRINE","title":"IntegrateWise — Operator Loop Doctrine","section":"business","sectionLabel":"Business","status":"unclassified","type":"document","path":"business/OPERATOR_LOOP_DOCTRINE.mdx","bytes":14333,"description":null,"updated":null,"source":"integratewise/Integratewise-docs-wiki","content":"\n**v1.0 · May 28, 2026**  \n**Author:** Nirmal, Founder  \n**Scope:** Internal reference. The operational proof of Architecture v2.0.  \n**Companion to:** `docs/ARCHITECTURE_V2.md`\n\n---\n\n> The Twin generates the _what_. The Operator executes the _how_. MCP closes the loop automatically.\n\n---\n\n## The Three Agents in the System\n\n| Agent                      | What It Is                                 | What It Does                                                                   |\n| -------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------ |\n| **IntegrateWise**          | The engine                                 | Normalizes, detects, reasons, surfaces, recommends, routes                     |\n| **IntegrateWise Ops**      | The operational layer inside IntegrateWise | Manages the playbook — what needs to happen, in what order, with what priority |\n| **IntegrateWise Operator** | The human CSM                              | Executes in native tools (HubSpot, Jira, Slack, Calendar)                      |\n\n---\n\n## The Handoff Point\n\n```\nINTEGRATEWISE ENGINE                    OPERATOR (Human)\n───────────────────                    ────────────────\nSpine: data normalized\n        │\n        ▼\nSignalAnalyzer: \"Acme Corp at risk\"\n        │\n        ▼\nIntelligent Routing:\n\"Here's the playbook for Acme Corp:\"\n\n┌─────────────────────────────────────────┐\n│ PRIORITY 1 — Today                      │\n│ → Escalate ACME-234 in Jira to eng lead │\n│   Why: 14-day P1, SLA breached          │\n│   Tool: Jira                            │\n│   Action: Set priority=Critical,        │\n│           assign=eng lead,              │\n│           add comment                   │\n│                                         │\n│ PRIORITY 2 — This week                  │\n│ → Schedule QBR with Acme CTO            │\n│   Why: No engagement 18 days,           │\n│         renewal in 42 days              │\n│   Tool: HubSpot + Calendar              │\n│   Action: Create meeting,               │\n│           log activity                  │\n│                                         │\n│ PRIORITY 3 — This week                  │\n│ → Send product roadmap update           │\n│   Why: Champion asking about features,  │\n│         expansion deal at risk          │\n│   Tool: HubSpot email                   │\n│   Action: Draft from template,          │\n│           personalize, send             │\n│                                         │\n│ ESTIMATED IMPACT:                       │\n│ Health score: 52 → 68 (if all done)     │\n│ Risk level: HIGH → MEDIUM               │\n│ Renewal confidence: 40% → 72%           │\n└─────────────────────────────────────────┘\n        │\n        │ ← HANDOFF\n        ▼\nOPERATOR sees this in the workbench\nReads the playbook\nMakes the judgment call\nExecutes in native tools\n\nIn Jira: escalates ACME-234        ✓\nIn HubSpot: schedules QBR          ✓\nIn HubSpot: sends roadmap email    ✓\n        │\n        │ ← RETURN (via MCP read)\n        ▼\nINTEGRATEWISE ENGINE (next sync)\n        │\n        ▼\nMCP connector re-reads HubSpot + Jira\n        │\n        ▼\nNormalizer detects changes:\n- ACME-234 priority changed to Critical\n- New calendar event: QBR June 3\n- New activity: roadmap email sent\n        │\n        ▼\nSpine updates:\n- account_master.last_engagement_date = today\n- risk.mitigation_status = \"in progress\"\n- engagement_log: new entry (email sent)\n- task_item: ACME-234 escalated\n        │\n        ▼\nSignalAnalyzer re-evaluates:\n- Health score recalculated: 52 → 64\n- Risk level: HIGH → MEDIUM\n- Renewal confidence: 40% → 68%\n        │\n        ▼\nMemory records:\n\"On May 28, Operator escalated ACME-234,\nscheduled QBR for June 3, sent roadmap update.\nRisk reduced from HIGH to MEDIUM.\nNext check: June 4 (post-QBR).\"\n        │\n        ▼\nNext playbook generated for next cycle\n```\n\n---\n\n## Where the Handoff Occurs\n\nThe handoff is the **intelligent routing output** — the ordered, prioritized, tool-specific playbook that the Operator receives.\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│                    HANDOFF BOUNDARY                          │\n│                                                              │\n│   INTEGRATEWISE PROVIDES:          OPERATOR EXECUTES:        │\n│                                                              │\n│   ✓ What to do                    ✓ In which tool            │\n│   ✓ In what order                 ✓ With what judgment       │\n│   ✓ With what priority            ✓ With what context        │\n│   ✓ For which account             ✓ With what timing         │\n│   ✓ Why (data-backed)             ✓ With what tone           │\n│   ✓ Expected impact               ✓ With what relationship   │\n│   ✓ In which tool                                            │\n│   ✓ What specific action                                     │\n│                                                              │\n│   This is INTELLIGENCE.            This is EXECUTION.        │\n│   IntegrateWise owns this.         The Operator owns this.   │\n│                                                              │\n└─────────────────────────────────────────────────────────────┘\n```\n\nThe handoff is not a button click. It's not \"approve and we'll send the email.\" It's:\n\n> **\"Here is the complete playbook. You are the Operator. Execute in your tools. We'll see the results on the next sync.\"**\n\n---\n\n## How the Results Return\n\nThe Operator doesn't \"submit results\" back to IntegrateWise. The MCP connectors **pull the results automatically** on the next sync cycle.\n\n```\nOperator executes in Jira (escalates ticket)\n        │\n        │ [hours pass]\n        │\n        ▼\nMCP connector reads Jira on scheduled sync\n        │\n        ▼\nNormalizer detects: ACME-234 has changed\n- priority: High → Critical\n- assignee: unassigned → eng lead\n- new comment: \"Escalated per CSM recommendation\"\n        │\n        ▼\nSpine updates the entity\n        │\n        ▼\nSignalAnalyzer sees: mitigation in progress\n        │\n        ▼\nRisk score adjusts automatically\n        │\n        ▼\nMemory records the outcome\n        │\n        ▼\nNext playbook reflects the new state\n```\n\n**The Operator never \"reports back.\"** IntegrateWise sees the results because it reads the same tools the Operator writes to. The loop closes automatically. That's the architecture — the Operator is inside the loop, not outside it.\n\n---\n\n## Where We Prove This Architecture\n\n**The proof is the closed loop.** Not just one direction. The full cycle:\n\n| Phase           | What Happens                                | Where It Happens                      | Proof                                                         |\n| --------------- | ------------------------------------------- | ------------------------------------- | ------------------------------------------------------------- |\n| **1. Detect**   | SignalAnalyzer identifies Acme Corp at risk | IntegrateWise engine                  | Risk signal appears in At-Risk Brief                          |\n| **2. Route**    | Intelligent playbook generated              | IntegrateWise Ops                     | Playbook shows prioritized actions with tool, reason, impact  |\n| **3. Handoff**  | Operator receives the playbook              | Workbench (Account detail)            | Operator reads it, understands it, knows what to do           |\n| **4. Execute**  | Operator acts in native tools               | HubSpot, Jira (outside IntegrateWise) | Jira ticket escalated, QBR scheduled, email sent              |\n| **5. Return**   | MCP connectors re-read the tools            | IntegrateWise engine                  | Changes detected, entities updated                            |\n| **6. Close**    | SignalAnalyzer re-evaluates                 | IntegrateWise engine                  | Risk score drops, memory records outcome                      |\n| **7. Compound** | Next playbook generated from enriched state | IntegrateWise Ops                     | New playbook reflects what was done, what worked, what's next |\n\n**The proof moment:** When the Operator executes step 4, and IntegrateWise sees the results in step 5 without the Operator doing anything to \"report back.\" The architecture proves itself when the loop closes automatically.\n\n---\n\n## The OpenClaw Demo (Corrected)\n\n```\n[Minute 0-2]\n\"I manage 25 accounts. My data lives in HubSpot and Jira.\nIntegrateWise connected to both. Read-only. My tools aren't affected.\"\n\n[Minute 2-4]\n\"The engine ran. It normalized my HubSpot companies and Jira projects\ninto canonical accounts. Same entity, one view.\"\n\n[Minute 4-6]\n\"At-Risk Brief. Acme Corp flagged. Health dropped, 3 P1 bugs,\nno engagement in 18 days.\"\n\n[Minute 6-8]\n\"Entity 360. Everything about Acme Corp from both tools in one\nintelligence canvas. I used to build this picture in my head from 4 tabs.\"\n\n[Minute 8-10]\n\"Intelligent routing. IntegrateWise didn't just tell me 'Acme is at risk.'\nIt told me: 'Escalate ACME-234 in Jira today. Schedule QBR this week.\nSend roadmap update.' In that order. With that priority.\nFor that reason. In that tool.\"\n\n[Minute 10-12]\n\"I'm the Operator. I execute in my tools. Watch —\nI escalate the Jira ticket.\nI schedule the QBR in HubSpot.\nI send the email.\"\n\n[Minute 12-14]\n\"Now watch what happens. The next sync runs. IntegrateWise sees that\nACME-234 was escalated. It sees the QBR is scheduled. It sees the email\nwas sent. Risk score drops from HIGH to MEDIUM.\nThe loop closed. Automatically.\"\n\n[Minute 14-16]\n\"Next playbook. IntegrateWise says: 'QBR is in 6 days. Prepare the\npre-read. Here's the account history. Here are the talking points.\nHere's what to cover.' The engine got smarter because it saw my actions.\"\n\n[Minute 16-17]\n\"Normalize Once, Render Anywhere. Two tools in. Intelligent routing out.\nI execute. The loop closes. Memory compounds. This is IntegrateWise.\"\n```\n\n---\n\n## The Architecture, Restated\n\n```\n┌──────────────────────────────────────────────────────────┐\n│                                                          │\n│  INTEGRATEWISE ENGINE                                    │\n│                                                          │\n│  MCP ──→ Loader ──→ Normalizer ──→ Spine                │\n│                                      │                   │\n│                                      ▼                   │\n│                              SignalAnalyzer              │\n│                                      │                   │\n│                                      ▼                   │\n│                             Intelligent Routing          │\n│                              (the playbook)              │\n│                                      │                   │\n│                                      ▼                   │\n│  ┌────────────────────────────────────────────────────┐  │\n│  │              HANDOFF BOUNDARY                      │  │\n│  │                                                    │  │\n│  │   IntegrateWise provides: the playbook             │  │\n│  │   Operator executes: in native tools               │  │\n│  │                                                    │  │\n│  └────────────────────────────────────────────────────┘  │\n│                                      │                   │\n│                                      ▼                   │\n│  MCP re-reads tools ◄── Operator's actions detected      │\n│      │                                                    │\n│      ▼                                                    │\n│  Spine updates ──→ SignalAnalyzer re-evaluates            │\n│      │                      │                             │\n│      ▼                      ▼                             │\n│  Memory records      Next playbook generated              │\n│      │                                                    │\n│      └──────────── Loop continues ────────────────────┘  │\n│                                                          │\n│  INTEGRATEWISE OWNS: Memory, Intelligence, Routing       │\n│  OPERATOR OWNS: Execution, Judgment, Timing              │\n│  MCP CONNECTS THE TWO                                    │\n│                                                          │\n└──────────────────────────────────────────────────────────┘\n```\n\n---\n\n## The One-Line Statement\n\n> **\"The Twin generates the what. The Operator executes the how. MCP closes the loop automatically.\"**\n\nThis is what Architecture v2.0 means. The Operator IS the execution stack. The playbook IS the handoff. The MCP re-read IS the return path. The loop IS the proof.\n\nThis is IntegrateWise.\n\n---\n\n_Document: IntegrateWise Operator Loop Doctrine v1.0_  \n_Author: Nirmal, Founder_  \n_Companion to: `docs/ARCHITECTURE_V2.md`_\n"}