{"slug":"internal/architecture/CANONICAL_PLATFORM_ARCHITECTURE","title":"IntegrateWise — Canonical Platform Architecture","section":"internal","sectionLabel":"Internal","status":"superseded","type":"document","path":"internal/architecture/CANONICAL_PLATFORM_ARCHITECTURE.mdx","bytes":82896,"description":null,"updated":null,"source":"integratewise/Integratewise-docs-wiki","content":"\n**Status:** SUPERSEDED — historical platform synthesis\n**Date:** July 12, 2026  \n**Authority:** Nirmal (Founder)  \n**Version:** 2.1 (Architecture corrections: Spine network topology, Activation/Continuity Bridge separation, Capability Fabric expansion)\n\n> Do not implement from this file where it conflicts with\n> [`INTEGRATEWISE_ARCHITECTURE.md`](INTEGRATEWISE_ARCHITECTURE.md) v2.2 or its\n> [`SPEC_AMENDMENTS_v1.md`](SPEC_AMENDMENTS_v1.md).\n> In particular, provider-configurable truth stores and an always-active Twin\n> are superseded.\n\n---\n\n## Operational Continuity Infrastructure with Governed Intelligence\n\n---\n\n### Core Doctrine\n\n> **Truth you own. AI you rent. Approval in between.**\n\nIntegrateWise is operational continuity infrastructure with governed intelligence. It connects the systems an organization already runs, converts their activity into canonical operational truth, composes role-aware Workbenches on top of that truth, and lets humans and their Tandem Twin operate together under explicit authority and approval. Every intent, evidence trail, outcome, and approval flows through a Continuity Pipeline that returns to the Adaptive Spine, so the next OODA loop begins with more context than the last.\n\nThe organization owns its operational truth in the Adaptive Spine. The Twin provides rented intelligence — reasoning, drafting, retrieval, and proposals — but never gets a direct Act button. Every consequential execution is gated by human approval and by Governance.\n\n**The user never opens a provider tool to do work. The Workbench is the tool. Every action that can be performed inside Salesforce, Jira, Slack, Stripe, HubSpot, Linear, GitHub, Zendesk, Intercom, QuickBooks, or any connected system can be executed from the Workbench surface itself. The user stays in one place. The platform reaches into every system on their behalf.**\n\n**The Twin is not waiting to be asked. The Twin is always present, always watching, always contextually aware. Every click, every field change, every navigation, every data interaction is observed by the Twin in real time. The Twin sees what the user sees. The Twin knows what the user knows. The Twin has already retrieved the memory, the history, the relationships, the evidence, and the next-best-action before the user finishes thinking about it. The user never provides context. The user never restates data. The user never explains what they are working on. The Twin already knows.**\n\n---\n\n### The Four-Button OODA Grammar\n\nThe User Workbench interaction model is exactly four canonical buttons, mapped directly to the OODA loop. These are the universal interaction grammar across every Workbench — not domain-specific action button chaos.\n\n| OODA    | Canonical Action   | Button                    | System Meaning                                                                               |\n| ------- | ------------------ | ------------------------- | -------------------------------------------------------------------------------------------- |\n| Observe | Capture truth      | **Store in Spine**        | Persist context, evidence, decision, note, or artifact into canonical Digital Memory         |\n| Orient  | Understand context | **Ask Your Twin**         | Query the Twin using current workspace + Continuity Bridge + Spine context                   |\n| Decide  | Delegate intent    | **Assign Your Twin**      | Give the Twin an objective to plan, reason, draft, or prepare an action                      |\n| Act     | Govern execution   | **Approve Twin's Action** | Human approval authorizes Hermes / capability execution. Twin never gets a direct Act button |\n\nThe critical authority boundary is:\n\n```\nSTORE\nUser ────────────────► Spine\n\nASK\nSpine + Context ─────► Twin ─────► Insight\n\nASSIGN\nUser ────────────────► Twin ─────► Proposal\n\nAPPROVE\nHuman ───────────────► Governance ─────► Hermes ─────► Capability\n```\n\nThe fourth button is deliberately **Approve Twin's Action** — not Run Twin, not Execute, not Automate. That is what preserves the doctrine.\n\n> **Truth you own. AI you rent. Approval in between.**\n\n---\n\n## 1. Signup and Tenant Activation\n\nThe IntegrateWise lifecycle begins when an organization creates a workspace. The platform establishes:\n\n- Organization\n- Tenant\n- Workspace\n- Users\n- Departments\n- Roles\n- Identity\n- Entitlements\n\nThis creates the initial tenant boundary. No operational workspace is assumed yet. The tenant must first be configured and connected.\n\n---\n\n## 2. Configuration Manager\n\n### Define how the organization operates.\n\nConfiguration Manager owns the compiled operating configuration of the tenant. It defines:\n\n**Organization Structure** — Departments, teams, roles, personas, scopes, and user relationships.\n\n**Infrastructure Choices** — Spine provider, cache provider, blob storage, memory infrastructure, event infrastructure, and supported runtime providers.\n\n**AI Choices** — Model providers, preferred models, embedding providers, reasoning policy, fallback models, and AI runtime rules.\n\n**Memory Policy** — User Memory, Work Memory, Organization Memory, Twin Memory, retention and promotion rules.\n\n**Governance Policy** — Authority, risk levels, approval requirements, evidence requirements, capability restrictions.\n\n**Sync Policy** — Immediate, deferred, scheduled, batch, event-driven, reconciliation.\n\n**Composition Policy** — Which fields, data, memories, and capabilities are relevant to each role and department.\n\nConfiguration Manager produces the **Compiled Tenant Config**. The platform runtime is driven by configuration. Infrastructure remains provider-configurable behind stable IntegrateWise contracts. Configuration Manager does not connect systems or execute capabilities — it defines how the organization operates.\n\n---\n\n## 3. Integration Manager — Four Connection Paths\n\n### Connect the organization's operating ecosystem.\n\nIntegrateWise does not treat every connection as an API integration. Different systems expose different operating contracts. IntegrateWise preserves those differences through four distinct paths.\n\n| Path              | Purpose                                                  | Contract                        |\n| ----------------- | -------------------------------------------------------- | ------------------------------- |\n| **MCP**           | Tool / resource discovery and invocation                 | Tool protocol                   |\n| **AI Connector**  | Connect models and AI runtimes                           | Intelligence provider contract  |\n| **API Connector** | Connect external SaaS / system APIs                      | Provider integration contract   |\n| **API Wrapper**   | Convert an API / function into an IW-governed capability | Capability abstraction contract |\n\n### MCP — Tool Protocol\n\nConnects tool and resource protocols. Discovers available tools, resources, prompts, and schemas from an MCP server and invokes them through a governed MCP execution path. MCP connects **tools**.\n\n### AI Connector — Intelligence Provider Contract\n\nConnects intelligence providers and AI runtimes. Provides access to models, embeddings, reasoning systems, multimodal intelligence, and specialized AI services through a model-agnostic provider contract. AI Connector connects **intelligence**. No model owns canonical operational truth.\n\n### API Connector — Provider Integration Contract\n\nConnects operational systems. Owns provider authentication, OAuth lifecycle, provider schemas, objects, fields, events, reads, writes, webhooks, cursors, checkpoints, incremental hydration, and synchronization. API Connector connects **systems**.\n\n### API Wrapper — Capability Abstraction Contract\n\nConverts an existing callable operation into an IntegrateWise capability. The source may be an API endpoint, an internal service, a serverless function, a workflow, a legacy operation, or a private enterprise service. The wrapper defines intent, inputs, outputs, authority, evidence requirements, execution mode, risk, and governance policy. API Wrapper creates **capabilities**.\n\n### The Four-Path Law\n\n**API Connectors connect systems. MCP connects tools. AI Connectors connect intelligence. API Wrappers create capabilities.**\n\nFour paths. Four contracts. One governed platform.\n\nAll four become available to the wider Capability Fabric, but they do not enter it through the same lifecycle or contract.\n\n---\n\n## 4. Activation Bridge\n\n### Compile the tenant into an active operational workspace.\n\nActivation Bridge combines Compiled Tenant Configuration + Connected Ecosystem + Organization Structure + User Identity + Department + Role + Available Data + Available Capabilities + Governance Policy.\n\nThe Activation Bridge resolves: Role, Department, Connected systems, Available tool categories, Relevant entities, Required fields, Data composition rules, Memory scopes, Authorized capabilities, AI runtime, Sync policy, and Governance boundaries.\n\nIt produces the **Active Workspace Definition**. Activation then begins hydration in three stages:\n\n**Instant Hydration** — Identity, Configuration, Roles, Connections, Available capabilities, Hot context.\n\n**Operational Hydration** — Active entities, Current records, Recent activity, Current work, Open tasks, Operational relationships.\n\n**Historical Hydration** — Historical records, Documents, Past decisions, Long-term activity, Historical relationships, Organizational knowledge.\n\nThe workspace becomes useful immediately and deepens continuously.\n\n---\n\n## 5. Common Connected Surface, Creamy Load, Delta Load, and Spine Networking\n\n### The Common Connected Surface\n\nIntegrateWise does not present each connected tool as an isolated integration. The platform creates a **Common Connected Surface** across every connected category:\n\n```\nCRM · Support · Communication · Billing · Product · Projects\nFinance · Engineering · Hiring · Legal · Marketing · Operations\nFiles · AI systems · MCP tools · Internal services · Knowledge bases\n```\n\nEach system retains its provider boundary. IntegrateWise creates a shared operational layer across them. The surface allows data and context from multiple tools to participate in the same operational work — without forcing the user to manually reconstruct relationships across systems.\n\n### Creamy Load — Build the Initial Connected State\n\nCreamy Load is the first deep hydration of the connected ecosystem. It discovers, retrieves, normalizes, relates, and prepares connected data for operational use.\n\n```\nDISCOVER      Inspect schemas, objects, fields, resources, events, access patterns\n     ↓\nSELECT        Apply tenant config, role rules, composition rules, entity priorities, data policy\n     ↓\nEXTRACT       Retrieve selected operational data from connected systems\n     ↓\nPARSE         Mechanically understand provider-specific payloads\n     ↓\nNORMALIZE     Convert provider structures into IW canonical primitives\n     ↓\nSYNTHESIZE    Resolve semantic meaning · identify entities · map fields · detect relationships\n     ↓\nRELATE        Build operational relationships across tools\n              Account ↔ Tickets · Account ↔ Invoices · Account ↔ Product Usage\n              Account ↔ Conversations · Account ↔ Projects · Account ↔ Decisions\n              Candidate ↔ Interview · Deal ↔ Communication · Invoice ↔ Expense\n     ↓\nGOVERN        Apply scope, memory scope, retention, authority, promotion policy\n     ↓\nPROMOTE       Promote approved operational state into the Adaptive Spine\n     ↓\nHYDRATE       Build Spine Cache, Entity 360, continuity bundles, Workbench surfaces\n```\n\n**Creamy Load = Deep Initial Context Formation.** The goal is not to copy every connected database — the goal is to create enough normalized and related operational state for the organization to begin working from IntegrateWise.\n\n### Delta Load — Continuously Absorb What Changed\n\nAfter Creamy Load establishes the initial operational state, connected systems move into Delta Load. Delta Load processes only new or changed operational information.\n\nDelta signals may originate from:\n\n```\nWebhooks · Provider events · Change data capture · Polling\nIncremental APIs · Updated timestamps · Cursor-based APIs\nMCP resource changes · File changes · Local Workbench mutations\nAgent outcomes · Tool-to-tool actions\n```\n\n```\nDETECT CHANGE\n     ↓\nCAPTURE DELTA\n     ↓\nRESOLVE SOURCE AND ENTITY\n     ↓\nPARSE → NORMALIZE → SYNTHESIZE\n     ↓\nCOMPARE WITH SPINE STATE\n     ↓\nGOVERN → PROMOTE OR QUEUE\n     ↓\nINVALIDATE / REFRESH CACHE\n     ↓\nREHYDRATE ACTIVE CONTEXT\n```\n\n**Creamy Load builds continuity. Delta Load maintains continuity.**\n\n### Spine Networking — The Network Effect\n\nIntegrateWise changes the integration topology. Without a continuity layer, organizations create point-to-point integration complexity — every new system increases integration proportional to N × M. IntegrateWise replaces that with a governed canonical context network:\n\n```\nPOINT-TO-POINT\nTool A ↔ Tool B\nTool A ↔ Tool C\nTool B ↔ Tool C\nTool C ↔ Tool D\n\n        N × (N - 1)\n        integration relationships\n\n\nINTEGRATEWISE\nTool A ─┐\nTool B ─┤\nTool C ─┼──► IW CONNECTED SURFACE / SPINE NETWORK\nTool D ─┤\nTool E ─┘\n\n        N provider connections\n        +\n        governed capability routes\n```\n\nThe Spine is not an ESB routing hub. It is the canonical context and continuity network.\n\n> **Tools connect once to IntegrateWise. Canonical entities and governed context become reusable across every authorized Workbench, Twin, agent, and capability.**\n\nThe Spine network enables:\n\n```\nCross-tool entity resolution\nCross-tool field composition\nCross-tool context retrieval\nCross-tool capability execution\nCross-tool event propagation\nCross-tool synchronization\nCross-tool memory\nCross-tool continuity\n```\n\nThe Spine does not blindly replicate every field to every system. It understands:\n\n| Spine Discipline     | Meaning                                                             |\n| -------------------- | ------------------------------------------------------------------- |\n| **Source Ownership** | Which system owns the authoritative source field                    |\n| **Canonical State**  | What operational truth IntegrateWise currently understands          |\n| **Consumer Scope**   | Which Workbench / Twin / agent / capability / system may consume it |\n| **Write Authority**  | Which system or capability may change the state                     |\n| **Sync Policy**      | When a resulting mutation should return to a connected source       |\n\n### Data Sharing Between Tools\n\nA connected tool does not automatically receive unrestricted access to every other tool's data. Sharing is resolved through the Spine network and governance policy. Data sharing is contextual, governed, traceable, and bidirectional when authorized.\n\n### The Common Connected Surface Formula\n\n```\nCONNECTED SYSTEMS + CREAMY LOAD + DELTA LOAD + ADAPTIVE SPINE\n+ SPINE NETWORKING + GOVERNED DATA SHARING + CAPABILITY FABRIC\n= COMMON CONNECTED SURFACE\n```\n\n> **One connected ecosystem. One Spine network. Many role-aware Workbenches.**\n\n---\n\n## 6. Normalized Data and Memory Pipeline\n\nConnected operational data enters the IntegrateWise pipeline:\n\n```\nCONNECT → CAPTURE → PARSE → NORMALIZE → SYNTHESIZE → GOVERN → PROMOTE → HYDRATE\n```\n\nProvider-specific data becomes operational continuity.\n\n---\n\n## 7. Adaptive Spine\n\n### Canonical operational truth.\n\nThe Adaptive Spine owns: Entities, Canonical fields, Relationships, Operational state, Lifecycle state, Work state, Decisions, Approved outcomes, Evidence references, Continuity state.\n\n**NO MODEL OWNS CANONICAL TRUTH.**\n\n**NO AGENT WRITES DIRECTLY TO THE SPINE.**\n\nChanges reach canonical state through governed promotion.\n\n---\n\n## 8. The IW State Planes\n\nIntegrateWise separates state according to semantic ownership.\n\n| Plane                 | Ownership                                                                           |\n| --------------------- | ----------------------------------------------------------------------------------- |\n| **Adaptive Spine**    | Canonical operational truth                                                         |\n| **Spine Cache**       | Disposable acceleration state — Hot Entity 360, Hydration Views, Context Bundles    |\n| **Twin Memory**       | Durable AI and user continuity — Preferences, Learned context, Memory summaries     |\n| **Twin Session Logs** | Interaction history — Conversations, Tool calls, Session state, Context lifecycle   |\n| **Twin Audit Logs**   | AI accountability — Intent, Model identity, Policy decisions, Approval lineage      |\n| **Knowledge**         | Semantic retrieval — Document chunks, Embeddings, Semantic indexes, Graph context   |\n| **Blobs**             | Binary and raw artifacts — Files, Attachments, Evidence, Exports                    |\n| **Sync State**        | Convergence progress — Cursors, Checkpoints, Pending mutations, DLQ, Conflict state |\n| **Config State**      | Tenant runtime choices — Compiled configuration, Composition rules, Policies        |\n| **Ephemeral Runtime** | Temporary coordination — Locks, Leases, Rate limits, Agent scratch state            |\n\nIdentity and Secrets, Telemetry, Queues, Events, Billing, Entitlements, Deployment, and Platform Administration operate as cross-cutting infrastructure planes.\n\n---\n\n## 9. Continuity Bridge\n\n### Deliver active context to the current runtime.\n\nThe Continuity Bridge is different from the Activation Bridge. Activation Bridge compiles and activates the workspace. Continuity Bridge continuously delivers the relevant context bundle to the active user, Workbench, Twin, agent, or capability runtime.\n\nThe Continuity Bridge resolves: User Memory, Work Memory, Organization Memory, Twin Memory, Active entities, Relevant relationships, Recent decisions, Current work state, Available evidence, Relevant knowledge, Capability context.\n\nIt produces the **Active Context Bundle**. The context bundle moves with the work. No model switch should begin cold. No workspace switch should require reconstructing operational history manually.\n\n---\n\n## 10. The Twin — Always Present, Always Contextual\n\n### A continuous AI work partner that never needs to be told what is happening.\n\nThe Twin is not a chatbot the user opens when they need help. The Twin is a persistent, ambient presence embedded in the Workbench surface. The Twin is always running. The Twin is always watching. The Twin always has context.\n\n**The user never gives the Twin data. The user never provides context. The user never explains what they are looking at, what account they are reviewing, what deal they are working on, or what problem they are solving. The Twin already knows.**\n\nEvery user action on the Workbench — every field viewed, every record opened, every filter applied, every data point hovered, every capability invoked, every note written, every decision made — is observed by the Twin in real time. The Twin maintains a continuous understanding of:\n\n- What the user is currently looking at\n- What the user just did\n- What the user is likely to do next\n- What changed since the user last worked on this entity\n- What memory and evidence are relevant to the current context\n- What other entities, tools, and data are connected to the current work\n- What risks, opportunities, and patterns exist in the current view\n- What the user's history, preferences, and working style suggest\n\nThe Twin operates with:\n\n- Active workspace context\n- Continuity Bridge context\n- Twin Memory\n- Relevant Spine state\n- Knowledge retrieval\n- Available capabilities\n- Governance boundaries\n\n### The Twin Always Knows Because the Platform Always Feeds It\n\nThe Continuity Bridge delivers a new Active Context Bundle every time the user's focus changes. When a CSM opens an account, the Twin immediately has:\n\n- The full entity relationship graph\n- The recent support tickets\n- The product usage deltas\n- The billing and renewal state\n- The communication history\n- The project milestones\n- The previous decisions about this account\n- The user's past actions on similar accounts\n- The organizational memory about this account\n- The evidence and documents related to renewal\n\nThe user does not provide any of this. The Twin receives it automatically through the Continuity Bridge, which is fed by the Adaptive Spine, which is fed by the Data Pipeline, which is fed by the four connection paths.\n\n**The context chain is:**\n\n```\nCONNECTED TOOLS\n     ↓ (Creamy Load + Delta Load)\nADAPTIVE SPINE\n     ↓ (Spine Cache + Knowledge)\nCONTINUITY BRIDGE\n     ↓ (Active Context Bundle)\nWORKBENCH SURFACE\n     ↓ (User action observation)\nTWIN RUNTIME\n     ↓ (Reasoning + Memory + Knowledge)\nSUGGESTION / PROPOSAL / INSIGHT\n```\n\n**At no point does the user enter the loop as a context provider. The user is the decision-maker, not the data transporter.**\n\n### The Twin Suggests Before Being Asked\n\nBecause the Twin is always observing and always contextually fed, it does not wait for the user to click \"Ask Your Twin.\" The Twin proactively surfaces:\n\n**Next-Best-Actions** — Based on the current entity state, the user's role, the OODA phase, and the organizational memory, the Twin suggests what the user should do next.\n\n**Risk Alerts** — When the Twin detects a pattern that suggests risk — a renewal at risk, a support escalation trend, a billing anomaly, a project delay, a candidate dropout signal — it surfaces the alert on the Workbench before the user asks.\n\n**Opportunity Signals** — When the Twin detects an expansion opportunity, an upsell signal, a cross-sell pattern, a process improvement, or an operational efficiency gain, it surfaces the suggestion.\n\n**Contextual Insights** — When the user is reviewing a record, the Twin automatically surfaces relevant memory, historical decisions, related entity changes, and cross-tool context that the user would otherwise need to manually retrieve.\n\n**Draft Completions** — When the user begins typing a note, composing a message, drafting a document, or preparing a proposal, the Twin can suggest completions, templates, or drafts based on the user's history, the entity context, and the organizational knowledge.\n\n**Capability Recommendations** — When the Twin detects that a capability the user is authorized to perform would be valuable in the current context — updating a field, sending a message, creating a ticket, scheduling a meeting, generating a report — it recommends the capability with the pre-filled context.\n\n### The Twin Proactively Does Not Act\n\nThe Twin suggests. The Twin proposes. The Twin drafts. The Twin does not execute without human approval. The Twin's proactive behavior is always in the **Orient** and **Decide** phases of OODA. It surfaces context and proposes action. The **Act** step remains the user's via \"Approve Twin's Action.\"\n\n```\nTWIN OBSERVES user behavior in real time\n     ↓\nTWIN UNDERSTANDS current context from Continuity Bridge\n     ↓\nTWIN RETRIEVES relevant memory, knowledge, evidence, relationships\n     ↓\nTWIN SUGGESTS next-best-action, risk alert, opportunity, or insight\n     ↓\nUSER SEES suggestion on Workbench surface\n     ↓\nUSER DECIDES\n     ↓\n  ┌──────────────┐\n  │ IGNORE       │ → Twin learns, adjusts future suggestions\n  │ ASK TWIN     │ → Twin provides deeper analysis\n  │ ASSIGN TWIN  │ → Twin prepares full proposal with execution plan\n  │ APPROVE      │ → Twin's proposed action executes through Governance → Hermes\n  └──────────────┘\n```\n\n### The Three Companion Stores\n\n| Store               | Contents                                                                                                                                    |\n| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |\n| **Twin Memory**     | Durable AI continuity, user preferences, learned context, what the user cares about, how the user works, what patterns the user responds to |\n| **Session Logs**    | Conversations, tool calls, session state, context lifecycle, what was suggested and what was done                                           |\n| **Twin Audit Logs** | Model / agent identity, intent, policy decision, approval lineage, full accountability trail                                                |\n\nAI Connectors feed intelligence into Twin, Specialist Agents, Hermes AI Tasks, and Synthesis / Embedding / Reasoning. Models remain replaceable. Continuity persists outside the model.\n\nThe Twin does not own canonical truth. The Twin does not bypass governance. The Twin proposes action. But the Twin never starts cold, never asks for context, and never waits to be told what is happening.\n\n---\n\n## 11. The User Workbench — Every Tool Category, Every Functionality, One Surface\n\n### The operational hub of every department.\n\nThe User Workbench is not a dashboard that shows data from other tools. The User Workbench **is the tool**. Every action a user would perform inside a connected system — updating a field, sending a message, creating a record, moving a card, approving a request, generating a report, scheduling a meeting, assigning a task, writing a note, processing a payment, resolving a ticket, pushing code, publishing content — is available as a composed capability on the Workbench surface.\n\n**The user never leaves the Workbench to do work in another tool. The Workbench reaches into every connected system and executes on the user's behalf.**\n\nEvery department works across a different combination of tools, data, memory, and workflows. IntegrateWise composes them into a role-aware User Workbench.\n\n### Every Tool Category Is Represented\n\n#### CRM / Sales\n\n**Connected Tools:** Salesforce, HubSpot, Pipedrive, Close, Zoho CRM, and any CRM via API Connector.\n\n**Workbench Capabilities — Executed Without Leaving the Workbench:**\n\n- View and update opportunity fields (stage, amount, close date, owner, probability)\n- Create and update contacts, accounts, and leads\n- Log calls, meetings, and activities\n- Send emails directly from the Workbench (synced back to CRM automatically)\n- Move deals through pipeline stages\n- Update forecast categories\n- Create and assign tasks\n- View deal history, stage duration, and velocity\n- Access relationship maps and engagement scoring\n- Generate proposals and quotes using Twin-drafted content\n- Trigger sequences and cadences\n- Update custom fields defined in the CRM schema\n- Merge duplicate records\n- Assign or reassign ownership\n- View competitor and product line associations\n\n**The Workbench reads and writes to Salesforce without opening Salesforce.** The API Connector handles authentication, schema mapping, and bidirectional sync. The user sees a composed field view and performs actions. The sync engine converges with the CRM according to policy.\n\n**Twin Behavior:**\n\n- Surfaces renewal risk when deal stage stalls beyond normal duration\n- Suggests next-best-action based on deal stage, competitor presence, and historical win patterns\n- Drafts follow-up emails using communication history and deal context\n- Alerts when a contact changes role or company\n- Proposes stage updates based on activity signals\n- Recommends when to escalate to a manager based on deal size and risk\n\n#### Customer Success\n\n**Connected Tools:** Gainsight, ChurnZero, Totango, Planhat, Vitally, and any CS platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View and update health scores\n- Manage renewal pipeline and forecast\n- Track adoption metrics and feature usage\n- Create and manage success plans\n- Log QBR notes and action items\n- Assign risk alerts and playbooks\n- Update lifecycle stages\n- Trigger interventions (email, call, escalation)\n- View NPS / CSAT scores and trends\n- Track expansion and upsell signals\n- Manage portfolios and account segments\n- Create and manage CTA (calls to action)\n\n**Twin Behavior:**\n\n- Auto-generates QBR decks from cross-tool context (CRM + Support + Product + Billing)\n- Predicts churn risk based on usage decline, support sentiment, and communication gaps\n- Suggests intervention playbooks based on similar account patterns\n- Drafts renewal conversations using relationship history\n- Surfaces feature adoption gaps that correlate with churn\n\n#### Support\n\n**Connected Tools:** Zendesk, Intercom, Freshdesk, Front, Help Scout, Jira Service Management, and any support platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View, update, and resolve tickets\n- Respond to tickets with Twin-drafted replies\n- Escalate tickets and assign to specialists\n- Create internal notes and public responses\n- Update ticket priority, status, category, and tags\n- Merge, split, and link tickets\n- View customer context alongside the ticket (CRM account, billing, product usage)\n- Trigger macros and automations\n- Manage SLA tracking and breach alerts\n- Access and insert canned responses\n- Create follow-up tasks\n- View ticket history and resolution patterns\n\n**The user handles support tickets alongside the account context, billing state, product usage, and communication history — all on one Workbench surface.**\n\n**Twin Behavior:**\n\n- Suggests ticket responses based on similar resolved tickets and knowledge base content\n- Surfaces relevant documentation and runbooks for the current issue\n- Detects escalation signals from sentiment analysis\n- Recommends ticket priority changes based on account value and SLA risk\n- Drafts internal summaries for escalated tickets\n- Identifies recurring issues that should become product feedback\n\n#### Communication\n\n**Connected Tools:** Slack, Microsoft Teams, Email (Gmail, Outlook), SMS, WhatsApp Business, and any messaging via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- Send and receive messages directly from the Workbench\n- Compose and schedule emails\n- Send Slack messages to channels or individuals\n- View communication history across all channels for an entity\n- Create Slack channels or Teams conversations for cross-functional work\n- Share documents and context directly from the Workbench\n- Set up notifications and alerts\n- Archive and search across communication history\n- Reply to email threads\n- Forward context and summaries to stakeholders\n\n**Communication is not a separate tool the user opens. Communication is an action available on the Workbench. The user composes and sends from the same surface where they review account context.**\n\n**Twin Behavior:**\n\n- Drafts communication based on the entity context, the user's voice, and the history of interactions\n- Suggests when to send a message based on engagement patterns\n- Surfaces the best channel for reaching a contact based on response history\n- Summarizes long email threads or Slack conversations\n- Recommends escalation communication when risk is detected\n\n#### Billing / Finance\n\n**Connected Tools:** Stripe, Chargebee, Recurly, QuickBooks, Xero, NetSuite, Zuora, and any billing/finance platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View invoices, payments, and billing history\n- Process refunds and credits\n- Update subscription plans and quantities\n- View revenue metrics (MRR, ARR, churn, expansion)\n- Manage payment methods and billing contacts\n- Create and send invoices\n- Track overdue payments and send reminders\n- View expense records and categorize transactions\n- Generate financial summaries\n- Reconcile billing with CRM opportunity data\n- View billing context alongside account and product data\n- Manage subscription lifecycle (trial, active, paused, cancelled)\n\n**Twin Behavior:**\n\n- Surfaces billing anomalies (unexpected churn, payment failures, downgrade signals)\n- Suggests renewal pricing based on usage trends and comparable accounts\n- Drafts payment reminder emails with context about the account relationship\n- Recommends plan changes based on usage patterns\n- Alerts when revenue at risk exceeds configured thresholds\n- Correlates billing changes with support activity and product usage\n\n#### Product\n\n**Connected Tools:** Productboard, Aha!, Linear, Jira, Notion, Confluence, Amplitude, Mixpanel, FullStory, and any product tool via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- View feature requests linked to customer accounts\n- Track product roadmap alongside customer context\n- View product usage analytics for specific accounts\n- Create and update feature requests\n- Link support tickets to product issues\n- View release notes and changelog\n- Track experiment results\n- Access product health dashboards\n- Submit and prioritize bugs\n- View customer feedback aggregated across tools\n- Map product usage to account health and renewal risk\n\n**Twin Behavior:**\n\n- Surfaces feature requests that correlate with churn risk\n- Recommends which product feedback to escalate based on revenue impact\n- Suggests product updates to communicate to specific account segments\n- Identifies usage patterns that predict expansion or contraction\n- Drafts product update communications for CSMs to share with accounts\n\n#### Engineering\n\n**Connected Tools:** GitHub, GitLab, Bitbucket, Linear, Jira, PagerDuty, Datadog, Sentry, and any engineering tool via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- View pull requests, issues, and deployments linked to customer context\n- Track incident status and impact on affected accounts\n- View code review status\n- Create and update issues directly from the Workbench\n- Link customer-reported bugs to engineering tickets\n- View deployment history and release status\n- Track on-call schedules and incident response\n- Access error rates and performance metrics for customer-facing services\n- View sprint progress alongside customer commitments\n\n**Twin Behavior:**\n\n- Surfaces engineering issues that affect at-risk accounts\n- Correlates incident reports with support ticket spikes\n- Drafts customer-facing incident communications\n- Recommends which bugs to prioritize based on customer revenue impact\n- Surfaces deployment risks before they affect production\n\n#### Marketing\n\n**Connected Tools:** Mailchimp, HubSpot Marketing, ActiveCampaign, Google Ads, Meta Ads, LinkedIn Ads, Webflow, WordPress, and any marketing platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View campaign performance alongside customer context\n- Track lead source and attribution\n- Manage email campaigns and sequences\n- View social media performance\n- Create and update content\n- Track SEO performance\n- Manage ad campaigns and budgets\n- View marketing-qualified leads and conversion metrics\n- Coordinate content with sales and CS for account-based marketing\n- Track brand mentions and sentiment\n\n**Twin Behavior:**\n\n- Suggests content topics based on support trends and product feedback\n- Recommends campaign targeting based on account segmentation\n- Drafts marketing copy using brand voice and historical performance\n- Surfaces underperforming campaigns and recommends adjustments\n- Identifies customer stories and case study candidates from account data\n\n#### Finance\n\n**Connected Tools:** QuickBooks, Xero, NetSuite, Brex, Ramp, Expensify, Bill.com, and any finance platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View financial statements and summaries\n- Process and approve expenses\n- Manage accounts payable and receivable\n- Track budget vs. actuals\n- View cash flow projections\n- Reconcile transactions\n- Generate financial reports\n- Manage vendor relationships and contracts\n- Track runway and burn rate\n- View departmental spend\n\n**Twin Behavior:**\n\n- Surfaces cash flow risks and unusual spend patterns\n- Suggests budget reallocations based on departmental performance\n- Drafts vendor negotiation talking points based on contract history\n- Alerts when expenses exceed category thresholds\n- Correlates revenue trends with operational costs\n\n#### Hiring / People\n\n**Connected Tools:** Lever, Greenhouse, Ashby, BambooHR, Gusto, Rippling, Workday, and any HR/ATS platform via API Connector.\n\n**Workbench Capabilities:**\n\n- View candidate pipeline and stage progression\n- Schedule interviews and manage calendar\n- Review candidate profiles and feedback\n- Send offer letters and manage negotiation\n- Track onboarding progress\n- View team structure and org chart\n- Manage PTO and time-off requests\n- View compensation benchmarks\n- Track hiring metrics (time-to-fill, source effectiveness)\n- Manage employee records and updates\n\n**Twin Behavior:**\n\n- Suggests candidate outreach based on role requirements and market data\n- Drafts offer letters using compensation policy and candidate context\n- Surfaces candidates at risk of dropping out based on communication gaps\n- Recommends interview questions based on role and candidate background\n- Identifies hiring bottlenecks in the pipeline\n\n#### Operations / Legal\n\n**Connected Tools:** DocuSign, Ironclad, Juro, Notion, Confluence, internal tools via API Wrapper, and any system via MCP.\n\n**Workbench Capabilities:**\n\n- View and manage contracts in progress\n- Send documents for signature\n- Track contract renewal dates and obligations\n- Manage vendor agreements\n- Review compliance status\n- Track internal approvals and policy changes\n- Manage SaaS vendor inventory and spend\n- View audit trails and governance logs\n- Handle NDA and DPA workflows\n\n**Twin Behavior:**\n\n- Surfaces upcoming contract renewals and suggests negotiation strategy\n- Drafts contract summaries and risk assessments\n- Alerts when vendor contracts auto-renew without review\n- Recommends compliance actions based on regulatory changes\n- Identifies SaaS spend optimization opportunities\n\n#### Business Intelligence\n\n**Connected Tools:** Looker, Metabase, Tableau, Mode, BigQuery, Snowflake, and any BI platform via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- View dashboards and reports composed from cross-tool data\n- Create and share ad-hoc queries\n- Track KPIs across departments\n- Generate executive summaries\n- Export data and visualizations\n- Set up automated reporting\n- Drill into entity-level detail from aggregate views\n\n**Twin Behavior:**\n\n- Generates narrative summaries of dashboards and metrics\n- Surfaces anomalies and trends in cross-departmental data\n- Suggests new metrics based on business goals\n- Drafts board-ready and investor-ready reports\n- Correlates operational metrics with strategic outcomes\n\n#### Internal Comms / Decisions / OKRs\n\n**Connected Tools:** Notion, Confluence, Loom, internal decision logs, and any knowledge system via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- Log decisions with evidence and authority\n- Track OKR progress across departments\n- Create and share meeting notes\n- Manage internal announcements\n- Track action items and commitments\n- Maintain decision history and rationale\n- Create and manage runbooks and playbooks\n\n**Twin Behavior:**\n\n- Drafts meeting summaries from session context\n- Surfaces decisions that may need revisiting based on changed conditions\n- Tracks OKR alignment across departments\n- Suggests OKR adjustments based on performance data\n- Maintains organizational memory about why past decisions were made\n\n#### Knowledge / Wiki\n\n**Connected Tools:** Notion, Confluence, Guru, Tettra, Slite, Google Docs, and any knowledge base via API Connector or MCP.\n\n**Workbench Capabilities:**\n\n- Search across all organizational knowledge\n- Create and update documentation\n- Link knowledge entries to entities and capabilities\n- Manage runbooks and playbooks\n- Track documentation freshness\n- Surface relevant knowledge in the current context\n\n**Twin Behavior:**\n\n- Automatically surfaces relevant knowledge entries based on the current entity and user action\n- Suggests documentation updates when processes change\n- Identifies knowledge gaps based on recurring questions\n- Drafts knowledge articles from resolved support tickets and past decisions\n\n#### Fundraising / Investor Relations\n\n**Connected Tools:** Affinity, Visible.vc, Carta, AngelList, internal dataroom, and any IR tool via API Connector.\n\n**Workbench Capabilities:**\n\n- Manage investor CRM and relationship pipeline\n- Track fundraising milestones and commitments\n- Generate investor updates from operational data\n- Manage dataroom access and document sharing\n- Track cap table and equity events\n- Prepare board materials from cross-departmental data\n\n**Twin Behavior:**\n\n- Drafts investor updates from revenue, product, and operational metrics\n- Surfaces investor engagement signals\n- Recommends investor outreach timing and content\n- Generates board deck narratives from platform data\n- Tracks investor communication cadence and relationship health\n\n### The Workbench Is the Tool\n\n**In every category above, the pattern is the same:**\n\n1. The user opens their Workbench\n2. Fields, data, memory, and capabilities from all connected tools are composed on one surface\n3. The user performs actions — reading, writing, updating, communicating, approving — without leaving the Workbench\n4. Every action executes through the Capability Fabric into the connected system\n5. Every outcome flows through the Continuity Pipeline back to the Spine\n6. The Workbench rehydrates with updated state\n7. The Twin observes every action and suggests the next one\n\n**The user never opens Salesforce to update an opportunity.**\n**The user never opens Zendesk to respond to a ticket.**\n**The user never opens Slack to send a message.**\n**The user never opens Stripe to process a refund.**\n**The user never opens Jira to create an issue.**\n**The user never opens Gmail to send an email.**\n**The user never opens QuickBooks to review a transaction.**\n\n**The Workbench is the operating surface. Every connected tool is a backend that the Workbench reaches into through governed capabilities.**\n\n### Customer Zero — One User, Every Walk, Every Day\n\nThe discipline started at home. Customer Zero is the IntegrateWise team itself running the company on the platform. A Customer Zero founder touches every category in a single day, with no team to delegate to.\n\nNo functional teams. No department walls. Just one founder, one company, every walk of work, every day.\n\nA department hub in a larger org covers a subset of those walks with role-based depth. A **CSM Workbench** = Account Success + Support + Billing + Product Usage + Communication. A **Finance Workbench** = Billing + Vendors + Subscriptions + Cash + Compliance. A **Founder Workbench** = all of the above, hydrated by whichever walk is active today.\n\nThe Workbench pattern is the same. The composition is what changes.\n\n### Composition Sources\n\n```\nCRM Tools        Billing Tools      Product Tools\nSupport Tools    Communication     Project Tools\nEngineering      Finance           Hiring Tools\nLegal & Comp.    Knowledge/Wiki    Fundraising / IR\nFiles            AI systems        MCP tools\nInternal services · Functions · Agents\n═══════════════════════════════════════════════\n            NORMALIZED PIPELINE\n        (Creamy Load + Delta Load + AI Enrichment)\n═══════════════════════════════════════════════\n            ADAPTIVE SPINE\n═══════════════════════════════════════════════\n   ROLE  +  DEPARTMENT  +  ACTIVE CONTEXT\n        +  POLICY  +  MEMORY SCOPE\n═══════════════════════════════════════════════\n   FIELD COMPOSITION  +  CAPABILITY COMPOSITION\n═══════════════════════════════════════════════\n            USER WORKBENCH\n```\n\n### Capabilities and Sync\n\nCapabilities may execute:\n\n- **Locally** against Workbench state and Spine — recorded immediately, synchronized later by policy\n- **Directly** through provider APIs / MCP / API Wrapper — execute against the source system, return outcome into the continuity pipeline\n- **Hybrid / Deferred** — combine local and API execution; converge on the configured schedule\n\nDifferent capabilities have different sync contracts. The capability definition — not the UI — decides.\n\n> Work now. Synchronize by policy. Preserve continuity always.\n\n---\n\n## 12. Capability Fabric\n\n### Resolve how work can be performed.\n\nUser intent or Twin intent enters the Capability Fabric. The Capability Fabric identifies available execution possibilities.\n\n| Path                       | Purpose                                                                                                    |\n| -------------------------- | ---------------------------------------------------------------------------------------------------------- |\n| **Tool → Tool**            | Move, transform, enrich, or coordinate information between tools                                           |\n| **Memory Fetch**           | Retrieve relevant operational or continuity memory                                                         |\n| **MCP Invocation**         | Invoke a discovered MCP tool or resource through its protocol contract                                     |\n| **Agent → Agent**          | Delegate specialized work between Twins, agents, or domain workers                                         |\n| **API Connector Action**   | Read or write through an established operational system connection                                         |\n| **API Wrapper Capability** | Invoke an IW capability created around an endpoint, function, service, or workflow                         |\n| **Local Execution**        | Perform a capability against local Workbench or runtime state                                              |\n| **AI Execution**           | Use an AI Connector for reasoning, synthesis, embeddings, multimodal analysis, or specialized intelligence |\n\nThe Capability Registry describes: Capability identity, Intent, Input schema, Output schema, Authority, Risk, Evidence requirements, Execution mode, Sync mode, Provider dependency.\n\nThe Capability Fabric answers: **HOW CAN THIS INTENT BE PERFORMED?** It does not decide whether the action is authorized. That belongs to Governance.\n\n---\n\n## 13. Governance Engine\n\n### Determine whether work may be performed.\n\nGovernance evaluates: Policy, Authority, Evidence, Risk, Scope, Approval.\n\nThree outcomes:\n\n```\nALLOW · DENY · REQUIRE APPROVAL\n```\n\n**No agent writes directly to the Spine.** All Spine mutations flow through approved capability execution and the Continuity Pipeline.\n\n**Approval is the boundary between AI intent and governed action.**\n\n---\n\n## 14. Hermes\n\n### The execution orchestrator.\n\nAfter authorization, Hermes coordinates execution:\n\n```\nResolve Capability → Select Runtime → Bind Context → Execute\nCoordinate Tools → Coordinate Agents → Observe → Retry → Reconcile\n```\n\nHermes **preserves intent + authority + context + execution lineage**. Hermes is the orchestrator. It is not canonical memory.\n\n---\n\n## 15. Execution Paths\n\nAn approved capability may execute through different runtime paths:\n\n**Local Execution** — Against local Workbench or platform state. Pending mutation for later synchronization.\n\n**API Connector Execution** — Directly against a connected operational system. Provider immediately updated.\n\n**MCP Execution** — A governed MCP tool invoked using its discovered tool contract.\n\n**API Wrapper Execution** — The wrapped endpoint, function, workflow, or service.\n\n**AI Execution** — An AI Connector provides model or intelligence capability.\n\n**Agent-to-Agent Execution** — Context and delegated intent move between authorized agents.\n\n**Tool-to-Tool Execution** — Cross-system workflow or transformation.\n\nExecution mode and synchronization mode are independent.\n\n---\n\n## 16. Sync Engine\n\n### Systems converge according to policy.\n\n```\nImmediate · Deferred · Batch · Scheduled · Event-Driven · Reconciliation\nFull Sync · Delta Sync · Continuous Sync\nCursors · Checkpoints · Pending Mutations · Retry · DLQ · Conflict State\n```\n\nA user may perform work locally. The connected provider may synchronize later according to policy.\n\n**WORK NOW. CONVERGE BY POLICY.**\n\n---\n\n## 17. Continuity Pipeline\n\nEvery governed execution produces an outcome event.\n\n```\nINTENT → ACTION → EVIDENCE → AUTHORITY → OUTCOME → STATE → MEMORY\n                    ↓\n              PROMOTE TO SPINE\n```\n\nThe Continuity Pipeline evaluates the resulting state and promotes canonical operational truth into the Adaptive Spine. Twin Memory is updated. Session history remains in Session Logs. Accountability remains in Audit Logs. Files remain in Blobs. Semantic representations are updated in Knowledge. Caches are refreshed. Sync state is advanced.\n\n---\n\n## 18. Workbench Rehydration and the Next OODA Loop\n\nThe updated Spine state flows into the hydration system. Spine Cache refreshes. Entity views update. Continuity context updates. The Continuity Bridge produces a new active context bundle. The User Workbench rehydrates. The Twin receives the updated context.\n\nThe next OODA loop begins.\n\n```\nOBSERVE → ORIENT → DECIDE → ACT → REMEMBER → REHYDRATE → REPEAT\n```\n\nEach loop begins with more continuity than the previous loop.\n\n---\n\n## The Data Continuity Loop\n\n```\nCONNECT          establish the source relationship\n     ↓\nCREAMY LOAD      build initial normalized and related operational state\n     ↓\nSPINE NETWORK    create cross-tool entity and context continuity\n     ↓\nCOMPOSE          build the Common Connected Surface and role-aware Workbench\n     ↓\nWORK             user, Twin, agent, or capability performs operational work\n     ↓\nEXECUTE          Hermes coordinates authorized execution\n     ↓\nSYNC             immediate · deferred · scheduled · batch · event-driven · reconciled\n     ↓\nDELTA LOAD       capture changes from source systems and local execution\n     ↓\nCONTINUITY       intent → action → evidence → authority → outcome → state → memory\nPIPELINE\n     ↓\nPROMOTE          update canonical operational truth\n     ↓\nREHYDRATE        refresh caches, context bundles, Twins, Workbenches\n     ↓\nREPEAT           the connected surface continuously evolves\n```\n\n---\n\n## The Platform Planes\n\n| Plane                     | Canonical Responsibility                                                           |\n| ------------------------- | ---------------------------------------------------------------------------------- |\n| **Configuration Manager** | Defines how the tenant operates                                                    |\n| **Integration Manager**   | Connects and discovers the tenant ecosystem                                        |\n| **Activation Bridge**     | Compiles configuration + connections + user context into an active workspace       |\n| **Pipeline**              | Converts provider activity into canonical operational state                        |\n| **Adaptive Spine**        | Owns canonical operational truth and creates the governed context network          |\n| **Spine Cache**           | Accelerates hydration and derived views                                            |\n| **Knowledge**             | Owns semantic retrieval representations                                            |\n| **Blobs**                 | Owns files, raw artifacts, and evidence                                            |\n| **User Workbench**        | Department hub composing cross-tool fields, data, memory, and capabilities         |\n| **Twin**                  | Reasons, retrieves, plans, delegates, proposes — always present, always contextual |\n| **Twin Memory**           | Owns durable AI/user continuity                                                    |\n| **Session Logs**          | Own interaction and runtime session history                                        |\n| **Twin Audit Logs**       | Own AI accountability and lineage                                                  |\n| **Capability Fabric**     | Resolves how an intent can be performed                                            |\n| **Governance Engine**     | Resolves whether and under whose authority it may be performed                     |\n| **Hermes**                | Orchestrates execution                                                             |\n| **Sync Engine**           | Controls system convergence                                                        |\n| **Continuity Pipeline**   | Converts outcomes back into persistent operational memory                          |\n\n## Cross-Cutting Infrastructure\n\n| Infrastructure Layer       | Concerns                                                              |\n| -------------------------- | --------------------------------------------------------------------- |\n| **Identity + Secrets**     | OAuth, API Keys, Service Identity, Delegated Authority, RBAC          |\n| **Config State**           | Tenant Config, Provider Selection, Composition Rules, Sync Policy     |\n| **Ephemeral Runtime**      | Locks, Leases, Agent Scratch State, Rate Limits, Temporary Context    |\n| **Queues + Events**        | Ingestion, Capability Jobs, Agent Jobs, Sync Jobs, Promotion Events   |\n| **Observability**          | Metrics, Traces, Errors, Model Usage, Capability Latency, Sync Health |\n| **Deployment + Runtime**   | Edge, Workers, Containers, Local Runtime, Regional Compute            |\n| **Billing + Entitlements** | Plan, Usage, Model Spend, Capability Access, Limits                   |\n| **Admin + Operations**     | Tenant Control, Runtime Health, Replay, DLQ, Policy Inspection        |\n\n---\n\n## The Complete End-to-End Architecture\n\n```\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                            INTEGRATEWISE                                    │\n│              OPERATIONAL CONTINUITY + GOVERNED INTELLIGENCE                 │\n└─────────────────────────────────────────────────────────────────────────────┘\n\n                                  ACTIVATE\n                                     │\n                                     ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         CONFIGURATION MANAGER                               │\n│  Tenant Config · Org Config · User Roles · Departments · Infrastructure     │\n│  Memory Providers · Model Providers · Storage · Cache · Sync Policy         │\n│  Governance Policy · Composition Rules · Capability Policy                  │\n│                    COMPILES THE TENANT RUNTIME                              │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                          INTEGRATION MANAGER                                │\n│   CONNECT                         AUTHENTICATE                    DISCOVER  │\n│   SaaS Tools                      OAuth / API Key                 APIs      │\n│   Databases                       Service Identity                MCP Tools │\n│   Files                           Delegated Authority             Resources │\n│   AI Providers                    Provider Tokens                 Schemas   │\n│   MCP Servers                                                    Events    │\n│   ┌──────────┬───────────────┬───────────────┬──────────────┐               │\n│   │ API      │ AI CONNECTOR  │     MCP       │ API WRAPPER  │               │\n│   │ CONNECTOR│               │               │              │               │\n│   └──────────┴───────────────┴───────────────┴──────────────┘               │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                           ACTIVATION BRIDGE                                 │\n│       CONFIGURATION              CONNECTIONS              USER CONTEXT       │\n│             └─────────────────────────┼─────────────────────────┘           │\n│                         COMPILE ACTIVE WORKSPACE                            │\n│                      Instant → Operational → Historical Hydration            │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                            DATA PIPELINE                                    │\n│  Creamy Load │ Delta Load │ Continuous Sync │ AI-Enriched Synthesis         │\n│  CONNECT → CAPTURE → PARSE → NORMALIZE → SYNTHESIZE → GOVERN → PROMOTE     │\n│                                      → HYDRATE                              │\n│                     RAW PROVIDER DATA → CANONICAL ENTITY MODEL              │\n│                              → CONTINUITY STATE                             │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                          COMMON CONNECTED SURFACE\n                              SPINE NETWORK EFFECT\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         ADAPTIVE SPINE                                      │\n│                         OPERATIONAL TRUTH                                   │\n│ Entities · Relationships · Fields · Decisions · Evidence · Work State       │\n│ Lifecycle State · Continuity State · Approved Outcomes                      │\n│                     NO MODEL OWNS CANONICAL TRUTH                           │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                 ┌──────────────────┼──────────────────┐\n                 ▼                  ▼                  ▼\n          SPINE CACHE           KNOWLEDGE            BLOBS\n          Hot Entity 360       Semantic Index      Documents\n          Hydration Views      Embeddings           Attachments\n          Context Bundles      Retrieval            Evidence\n                 └──────────────────┼──────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         ACTIVATION BRIDGE                                   │\n│                                                                             │\n│       CONFIGURATION              CONNECTIONS              USER CONTEXT       │\n│             │                         │                         │             │\n│             └─────────────────────────┼─────────────────────────┘             │\n│                                       ▼                                     │\n│                         COMPILE ACTIVE WORKSPACE                            │\n│                                                                             │\n│                      Instant → Operational → Historical Hydration            │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         CONTINUITY BRIDGE                                   │\n│                                                                             │\n│               SPINE + CACHE + KNOWLEDGE + USER CONTEXT                      │\n│                                      │                                      │\n│                                      ▼                                      │\n│                         ACTIVE CONTEXT BUNDLE                               │\n│                                      │                                      │\n│                   USER / WORK / ORG MEMORY SCOPE                            │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                          USER WORKBENCH                                     │\n│                    HUB OF EVERY DEPARTMENT                                  │\n│                                                                             │\n│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │\n│  │   CRM /  │ │ CUSTOMER │ │ SUPPORT  │ │  COMMS   │ │ BILLING  │          │\n│  │   SALES  │ │ SUCCESS  │ │          │ │          │ │ FINANCE  │          │\n│  │          │ │          │ │ Zendesk  │ │ Slack    │ │          │          │\n│  │Salesforce│ │ Gainsight│ │ Intercom │ │ Teams    │ │ Stripe   │          │\n│  │ HubSpot  │ │ ChurnZero│ │ Freshdesk│ │ Email    │ │ QuickBooks│         │\n│  │ Pipedrive│ │ Planhat  │ │ Front    │ │ SMS      │ │ Xero     │          │\n│  │ Close    │ │ Totango  │ │ HelpScout│ │ WhatsApp │ │ NetSuite │          │\n│  │          │ │ Vitally  │ │ Jira SM  │ │          │ │ Chargebee│          │\n│  └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘          │\n│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐          │\n│  │ PRODUCT  │ │ENGINEERING│ │MARKETING │ │  HIRING  │ │OPERATIONS│          │\n│  │          │ │          │ │          │ │  PEOPLE  │ │  LEGAL   │          │\n│  │Productbrd│ │ GitHub   │ │ Mailchimp│ │          │ │          │          │\n│  │ Aha!     │ │ GitLab   │ │ HubSpot  │ │ Lever    │ │ DocuSign │          │\n│  │ Linear   │ │ Jira     │ │ Active   │ │ Greenhse │ │ Ironclad │          │\n│  │ Amplitude│ │ PagerDuty│ │ Campaign │ │ Ashby    │ │ Juro     │          │\n│  │ Mixpanel │ │ Datadog  │ │ Google   │ │ BambooHR │ │ Notion   │          │\n│  │ FullStory│ │ Sentry   │ │ Ads      │ │ Gusto    │ │ Confluence│         │\n│  └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘          │\n│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐                       │\n│  │   BI     │ │ INTERNAL │ │KNOWLEDGE │ │  FUND-   │                       │\n│  │          │ │ COMMS    │ │   WIKI   │ │ RAISING  │                       │\n│  │ Looker   │ │ DECISIONS│ │          │ │   IR     │                       │\n│  │ Metabase │ │ OKRs     │ │ Notion   │ │          │                       │\n│  │ Tableau  │ │          │ │ Confluence│ │ Affinity │                       │\n│  │ Mode     │ │ Loom     │ │ Guru     │ │ Visible  │                       │\n│  │ BigQuery │ │ Notion   │ │ Tettra   │ │ Carta    │                       │\n│  │ Snowflake│ │          │ │ Slite    │ │          │                       │\n│  └──────────┘ └──────────┘ └──────────┘ └──────────┘                       │\n│                                                                             │\n│   EVERY FUNCTIONALITY EXECUTABLE WITHOUT LEAVING THE WORKBENCH              │\n│   EVERY ACTION SYNCED TO SOURCE SYSTEMS BY POLICY                           │\n│   EVERY FIELD COMPOSED FROM CROSS-TOOL CANONICAL STATE                      │\n│                                                                             │\n│       CROSS-CATEGORY FIELD + DATA + MEMORY + CAPABILITY COMPOSITION         │\n│              USER ROLE + DEPARTMENT + ACTIVE CONTEXT + POLICY               │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n                    ┌──────────────────────────────────────┐\n                    │      FOUR-BUTTON OODA GRAMMAR        │\n                    ├──────────────────────────────────────┤\n                    │ OBSERVE  → STORE IN SPINE            │\n                    │ ORIENT   → ASK YOUR TWIN             │\n                    │ DECIDE   → ASSIGN YOUR TWIN          │\n                    │ ACT      → APPROVE TWIN'S ACTION     │\n                    └────────────────┬─────────────────────┘\n                                     │\n                                     ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                               TWIN                                          │\n│                      CONTINUOUS AI WORK PARTNER                             │\n│              ALWAYS PRESENT · ALWAYS CONTEXTUAL · NEVER COLD                │\n│                                                                             │\n│   ┌─────────────────────────────────────────────────────────────────────┐   │\n│   │                    TWIN CONTEXT CHAIN                               │   │\n│   │                                                                     │   │\n│   │  CONNECTED TOOLS → ADAPTIVE SPINE → CONTINUITY BRIDGE               │   │\n│   │       → WORKBENCH SURFACE → USER ACTION OBSERVATION                 │   │\n│   │            → TWIN RUNTIME → SUGGESTION / PROPOSAL                   │   │\n│   │                                                                     │   │\n│   │  THE USER NEVER PROVIDES CONTEXT                                    │   │\n│   │  THE TWIN ALWAYS KNOWS                                              │   │\n│   └─────────────────────────────────────────────────────────────────────┘   │\n│                                                                             │\n│   ┌──────────────────┬────────────────────┬──────────────────────────────┐   │\n│   │   TWIN MEMORY    │   SESSION LOGS     │       TWIN AUDIT LOGS       │   │\n│   │                  │                    │                              │   │\n│   │ Durable AI       │ Conversations      │ Model / Agent Identity       │   │\n│   │ Continuity       │ Tool Calls         │ Intent                       │   │\n│   │ User Preferences │ Session State      │ Policy Decision              │   │\n│   │ Learned Context  │ Context Lifecycle  │ Approval Lineage             │   │\n│   └──────────────────┴────────────────────┴──────────────────────────────┘   │\n│                                                                             │\n│   PROACTIVE BEHAVIORS:                                                      │\n│   • Next-Best-Action suggestions based on entity state + history            │\n│   • Risk alerts surfaced before the user asks                               │\n│   • Opportunity signals detected from cross-tool patterns                   │\n│   • Contextual insights auto-surfaced when entity is opened                 │\n│   • Draft completions offered as user begins composing                      │\n│   • Capability recommendations with pre-filled context                      │\n│   • The Twin suggests in Orient/Decide — Act remains human-gated            │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         CAPABILITY FABRIC                                   │\n│                                                                             │\n│                     RESOLVE HOW WORK GETS DONE                              │\n│                                                                             │\n│  TOOL → TOOL       MEMORY FETCH       MCP             AGENT → AGENT         │\n│                                                                             │\n│  API CONNECTOR     API WRAPPER        LOCAL           AI EXECUTION          │\n│  ACTION            CAPABILITY         EXECUTION       (AI CONNECTOR)        │\n│                                                                             │\n│                       CAPABILITY REGISTRY                                   │\n│                                                                             │\n│ Schema · Input · Output · Authority · Execution Mode · Sync Mode            │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                         GOVERNANCE ENGINE                                   │\n│ Policy · Authority · Evidence · Risk · Scope · Approval                     │\n│                 ALLOW · DENY · REQUIRE APPROVAL                             │\n│                    NO AGENT WRITES DIRECTLY TO SPINE                        │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                              HERMES                                         │\n│                       EXECUTION ORCHESTRATOR                                │\n│ Resolve Capability → Select Runtime → Bind Context → Execute                │\n│ Coordinate Tools → Coordinate Agents → Observe → Retry → Reconcile          │\n│              PRESERVES INTENT + AUTHORITY + EXECUTION LINEAGE               │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n              ┌─────────────────────┼───────────────────────┐\n              ▼                     ▼                       ▼\n      LOCAL EXECUTION          API EXECUTION          DISTRIBUTED EXECUTION\n      Workbench State          Provider API             Tool → Tool\n      Local Capability         Source System            MCP\n                                                   Agent → Agent\n              └─────────────────────┼───────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                            SYNC ENGINE                                      │\n│ Immediate · Deferred · Batch · Scheduled · Event-Driven · Reconciliation    │\n│ Cursors · Checkpoints · Pending Mutations · Retry · DLQ · Conflict State    │\n│                      SYSTEMS CONVERGE BY POLICY                             │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    ▼\n┌─────────────────────────────────────────────────────────────────────────────┐\n│                       CONTINUITY PIPELINE                                   │\n│        INTENT → ACTION → EVIDENCE → OUTCOME → STATE → MEMORY                │\n│                         PROMOTE TO SPINE                                    │\n└───────────────────────────────────┬─────────────────────────────────────────┘\n                                    │\n                                    └──────────────► ADAPTIVE SPINE\n                                                        │\n                                                        ▼\n                                               WORKBENCH REHYDRATION\n                                                        │\n                                                        ▼\n                                                   NEXT OODA LOOP\n```\n\n---\n\n## Canonical Execution Sequence\n\n```\nConfiguration Manager\n   → Integration Manager\n   → Activation Bridge\n   → Common Connected Surface Bootstrap\n   → Creamy Load\n   → Spine Network\n   → Workbench Composition\n   → OODA / Twin\n   → Capability Fabric\n   → Governance\n   → Hermes\n   → Sync\n   → Delta Load\n   → Continuity Pipeline\n   → Spine Promotion\n   → Rehydration\n```\n\n---\n\n## The Complete IW Operating Model\n\n**Configuration Manager** defines how the tenant operates.\n\n**Integration Manager** connects systems, tools, intelligence, and capability sources through four distinct contracts — **MCP, AI Connector, API Connector, and API Wrapper**.\n\n**Activation Bridge** compiles the tenant, ecosystem, role, and policy into an active workspace.\n\n**Pipeline** transforms fragmented provider data into normalized operational context.\n\n**Adaptive Spine** owns canonical operational truth.\n\n**Continuity Bridge** delivers the right memory and context to the active runtime.\n\n**User Workbench** becomes the operational hub of every department — with every tool category composed and every functionality executable without leaving the surface.\n\n**Twin** is always present, always contextual, always suggesting — the user never provides context because the Twin always has it.\n\n**Capability Fabric** resolves how an intent can be performed.\n\n**Governance** determines whether and under whose authority it may be performed.\n\n**Hermes** coordinates governed execution.\n\n**Sync Engine** converges local and connected systems according to policy.\n\n**Continuity Pipeline** turns execution outcomes into persistent operational memory.\n\n**Spine** remembers.\n\n**Workbench** rehydrates.\n\n**OODA** repeats.\n\n---\n\n## INTEGRATEWISE\n\nOne operational hub for every department.\n\nEvery tool category composed. Every functionality executable from one surface.\n\nPersistent Twins with continuity — always present, always contextual, never cold.\n\nFour distinct connection and capability paths.\n\nGoverned capabilities across tools, systems, APIs, agents, and AI.\n\nThe user never leaves the Workbench. The user never provides context to AI.\n\nThe Twin sees what the user sees. The Twin knows what the user knows. The Twin suggests before being asked.\n\nLocal work with policy-driven synchronization. Canonical truth that no model owns.\n\n## Truth you own. AI you rent. Approval in between.\n\n## Your Data. Your Twin. Your Model. Your Yes / No Matters.\n\n## IntegrateWise is Operational Continuity Infrastructure with Governed Intelligence.\n"}