{"slug":"business/OPS_ECOSYSTEM_DOCTRINE","title":"IntegrateWise — Ops Ecosystem Doctrine","section":"business","sectionLabel":"Business","status":"unclassified","type":"document","path":"business/OPS_ECOSYSTEM_DOCTRINE.mdx","bytes":14148,"description":null,"updated":null,"source":"integratewise/Integratewise-docs-wiki","content":"\n**v1.0 · May 28, 2026**  \n**Author:** Nirmal, Founder  \n**Scope:** Internal reference. Defines the boundary between IntegrateWise and the Ops Ecosystem.  \n**Companion to:** `docs/ARCHITECTURE_V2.md`, `docs/OPERATOR_LOOP_DOCTRINE.md`, `docs/SELF_DEMONSTRATION_DOCTRINE.md`\n\n---\n\n> IntegrateWise is the single source of truth and the intelligence layer.  \n> The Ops Ecosystem is the separate ground where execution happens.  \n> Everything not running inside IntegrateWise runs outside it.\n\n---\n\n## The Fundamental Boundary\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│                    INTEGRATEWISE                             │\n│                                                              │\n│  Single source of truth.                                     │\n│  Normalizes. Detects. Reasons. Surfaces. Recommends.         │\n│  Provides the WHAT and WHY.                                  │\n│  Never executes. Never grounds.                              │\n│                                                              │\n│  Output: Playbook (ordered, prioritized, tool-specific)      │\n│                                                              │\n└──────────────────────────┬──────────────────────────────────┘\n                           │\n                    HANDOFF BOUNDARY\n                           │\n┌──────────────────────────▼──────────────────────────────────┐\n│                    OPS ECOSYSTEM                             │\n│                                                              │\n│  Separate ground. Where execution happens.                   │\n│  Where humans act. Where agents run.                         │\n│  Where things that can't be automated get done.              │\n│                                                              │\n│  Input: Playbook from IntegrateWise                          │\n│  Output: Actions in the world (tools, meetings, content)     │\n│                                                              │\n└─────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## The Two Modes of Execution\n\nExecution has two modes. Both live in the Ops Ecosystem. Neither lives inside IntegrateWise.\n\n### Mode 1 — Tool-Mediated Execution\n\nActions that go through connected tools. Can be automated or semi-automated.\n\n| Example                 | Tool            | Returns to IntegrateWise?       |\n| ----------------------- | --------------- | ------------------------------- |\n| Create a task in Jira   | Jira            | Yes — MCP re-reads on next sync |\n| Update a HubSpot record | HubSpot         | Yes — MCP re-reads on next sync |\n| Send an email           | HubSpot / Gmail | Yes — MCP re-reads on next sync |\n| Schedule a meeting      | Calendar        | Yes — MCP re-reads on next sync |\n| Post to Slack           | Slack           | Yes — MCP re-reads on next sync |\n\nThese actions write to tools. IntegrateWise sees the results on the next MCP sync. The loop closes automatically.\n\n### Mode 2 — Human-Grounded Execution\n\nActions that require human presence, judgment, creativity, or physical reality. Cannot be automated.\n\n| Example                              | Why it can't be automated                                  |\n| ------------------------------------ | ---------------------------------------------------------- |\n| CSM attends a meeting in person      | Requires physical presence, relationship, reading the room |\n| Design a LinkedIn post               | Requires creative judgment, brand voice, human taste       |\n| Create a LinkedIn page               | Requires account ownership, human verification             |\n| Build a relationship with a prospect | Requires trust, empathy, time                              |\n| Make a strategic decision            | Requires context, values, accountability                   |\n| Negotiate a contract                 | Requires human judgment, legal authority                   |\n\nThese actions happen in the world. IntegrateWise may learn about them (via memory write or MCP re-read), but it cannot perform them.\n\n---\n\n## What the Ops Ecosystem Is\n\nThe Ops Ecosystem is a **separate application surface** — not inside IntegrateWise — that:\n\n1. **Receives the playbook** from IntegrateWise (via the Handover Agent)\n2. **Routes actions** to the right executor (Hermes for orchestration, Claw for tool-mediated, human for grounded)\n3. **Tracks execution state** — what's been done, what's pending, what's blocked\n4. **Surfaces human-grounded tasks** — the things that need a human to show up\n5. **Feeds results back** — either via MCP (tool-mediated) or via memory write (human-grounded)\n\n### What it is NOT\n\n- It is not a second source of truth. IntegrateWise is the only source of truth.\n- It is not a reasoning layer. IntegrateWise reasons. The Ops Ecosystem executes.\n- It is not a data store. It reads from IntegrateWise. It writes back to IntegrateWise (via MCP or memory).\n- It is not the product. It is the operator's ground.\n\n---\n\n## The Ops Ecosystem Architecture\n\n```\n┌──────────────────────────────────────────────────────────────┐\n│                    OPS ECOSYSTEM                              │\n│                                                              │\n│  ┌─────────────────────────────────────────────────────────┐ │\n│  │  Ops Surface (integratewise-ops / IW OS)                │ │\n│  │                                                          │ │\n│  │  Playbook Viewer      — What IntegrateWise recommends    │ │\n│  │  Action Queue         — What needs to be done today      │ │\n│  │  Human Task Board     — What requires human presence     │ │\n│  │  Execution Log        — What has been done               │ │\n│  │  Hermes Console       — Orchestration status             │ │\n│  │  Claw Execution Log   — Tool-mediated action results     │ │\n│  │  Memory Write Panel   — Record human-grounded outcomes   │ │\n│  └─────────────────────────────────────────────────────────┘ │\n│                                                              │\n│  ┌──────────────────┐  ┌──────────────┐  ┌───────────────┐  │\n│  │ Hermes           │  │ Claw         │  │ Human         │  │\n│  │ (Orchestrator)   │  │ (Executor)   │  │ (Operator)    │  │\n│  │                  │  │              │  │               │  │\n│  │ Multi-step       │  │ Single-tool  │  │ Grounded      │  │\n│  │ coordination     │  │ writes       │  │ execution     │  │\n│  └──────────────────┘  └──────────────┘  └───────────────┘  │\n│                                                              │\n└──────────────────────────────────────────────────────────────┘\n                           │\n              ┌────────────┼────────────┐\n              │            │            │\n         MCP sync    Memory write   Manual log\n              │            │            │\n              ▼            ▼            ▼\n┌──────────────────────────────────────────────────────────────┐\n│                    INTEGRATEWISE                              │\n│  Spine updates. SignalAnalyzer re-evaluates.                  │\n│  Memory records. Next playbook generated.                     │\n└──────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## The Three Return Paths\n\nWhen execution happens in the Ops Ecosystem, results return to IntegrateWise via one of three paths:\n\n### Path 1 — MCP Sync (automatic)\n\nTool-mediated actions write to connected tools. MCP re-reads on the next sync cycle. IntegrateWise detects the change automatically. No manual reporting needed.\n\n```\nClaw creates Jira task → MCP reads Jira → Spine updates → loop closes\n```\n\n### Path 2 — Memory Write (semi-automatic)\n\nHuman-grounded actions that produce a recordable outcome. The Operator writes a memory entry via the Ops Surface. IntegrateWise receives it as org_memory (staging → approved → published).\n\n```\nCSM attends meeting → Operator writes: \"Met with Acme CTO. Agreed on QBR June 10.\"\n→ memory.org_memory (staging) → Triage Bot scores → approved → Spine knows\n```\n\n### Path 3 — Manual Log (human-initiated)\n\nActions that don't produce a tool artifact or a memory entry. The Operator logs the outcome manually. IntegrateWise records it as an activity.\n\n```\nLinkedIn post designed and published → Operator logs: \"Posted roadmap update on LinkedIn.\n340 impressions, 12 comments.\" → activity_log → Spine knows\n```\n\n---\n\n## The Ops Surface — `integratewise-ops` / IW OS\n\nThe `integratewise-ops` repository is the correct home for the Ops Ecosystem surface. It is:\n\n- **Separate** from the customer-facing product (`apps/web`)\n- **Separate** from the IntegrateWise engine (`integratewise-live`)\n- The **operator's ground** — where Nirmal, Hermes, and Claw work\n- The **internal power surface** — not shown to customers\n\nIt should evolve into **IW OS** — the full operator environment:\n\n| Section          | What it shows                                                         |\n| ---------------- | --------------------------------------------------------------------- |\n| Playbook         | Today's recommendations from IntegrateWise, ordered by priority       |\n| Action Queue     | Proposals pending approval or execution                               |\n| Human Task Board | Things that require human presence — meetings, content, relationships |\n| Hermes Console   | Orchestration status, active workflows, pending decisions             |\n| Claw Log         | Tool-mediated execution history, success/failure                      |\n| Memory Panel     | Write human-grounded outcomes back to IntegrateWise                   |\n| Signal Feed      | Live signals from IntegrateWise — what changed, what's at risk        |\n| Lineage View     | Full reasoning chain for any proposal                                 |\n\n---\n\n## The Decision — Locked\n\n```\nIntegrateWise (integratewise-live + apps/web)\n  → Customer-facing product\n  → Single source of truth\n  → Intelligence, reasoning, governance\n  → What the customer buys\n\nOps Ecosystem (integratewise-ops → IW OS)\n  → Internal operator surface\n  → Where Nirmal, Hermes, Claw execute\n  → Receives playbook from IntegrateWise\n  → Feeds results back via MCP / memory / log\n  → NOT the customer product\n  → NOT a second source of truth\n```\n\n**Everything not running inside IntegrateWise runs in the Ops Ecosystem.**  \n**IntegrateWise provides the intelligence. The Ops Ecosystem provides the ground.**\n\n---\n\n## The API Contract\n\nThe Ops Ecosystem consumes IntegrateWise via:\n\n```\nGET  /v1/proposals?ops_surface=command_center   → critical proposals\nGET  /v1/proposals?ops_surface=queue            → manual review queue\nGET  /v1/proposals?ops_surface=tile             → high priority tiles\nPOST /v1/proposals/:id/approve                  → human approves\nPOST /v1/proposals/:id/reject                   → human rejects (with reason)\nPOST /v1/proposals/:id/execute                  → operator starts execution\nPOST /v1/proposals/:id/complete                 → execution confirmed\nPOST /v1/proposals/:id/fail                     → execution failed\nGET  /v1/proposals/lineage/:lineage_id          → full reasoning chain\nGET  /v1/signals?tenant_id=...                  → live signal feed\nGET  /v1/twin/360/:entityId                     → Entity 360 for any entity\nPOST /memory/write_conversational               → write session memory (MCP tool)\nPOST /memory/upsert_org                         → write org memory (MCP tool)\n```\n\nThe response shape is `ProposalOpsProjection` — defined in `packages/types/src/proposal.ts`. The Ops Ecosystem never receives internal governance fields. It receives only what it needs to execute.\n\n---\n\n## The One-Line Statement\n\n> **IntegrateWise is the mind. The Ops Ecosystem is the hands.**\n\nIntegrateWise knows what needs to happen and why. The Ops Ecosystem is where it gets done — by Hermes, by Claw, by a human attending a meeting, by a CSM designing a LinkedIn post. The two are connected by the playbook going out and results coming back. Neither replaces the other.\n\n---\n\n_Document: IntegrateWise Ops Ecosystem Doctrine v1.0_  \n_Author: Nirmal, Founder_  \n_Companion to: `docs/ARCHITECTURE_V2.md`, `docs/OPERATOR_LOOP_DOCTRINE.md`, `docs/SELF_DEMONSTRATION_DOCTRINE.md`_\n"}