{"slug":"internal/architecture/ARCHITECTURE_V2","title":"IntegrateWise — Architecture Document","section":"internal","sectionLabel":"Internal","status":"unclassified","type":"document","path":"internal/architecture/ARCHITECTURE_V2.mdx","bytes":22323,"description":null,"updated":null,"source":"integratewise/Integratewise-docs-wiki","content":"\n**v2.0 · May 2025** \n**Author:** Nirmal, Founder \n**Scope:** Internal reference. Source of truth for product, docs, marketing, and pricing. \n**Supersedes:** All previous architecture descriptions.\n\n---\n\n> IntegrateWise is the governed memory and continuity layer for organisations. It does not aim to replace the customer's execution stack; instead, it connects to that stack through a global MCP-based connector layer, projects governed context into the workbench, and enables lightweight, approval-aware actions where necessary.\n>\n> **IntegrateWise owns memory. The customer owns execution. MCP connects the two.**\n\n---\n\n## 1. The Boundary\n\nIntegrateWise has a clear ownership boundary. Everything inside the boundary is IntegrateWise's responsibility. Everything outside belongs to the customer or the ecosystem.\n\n### IntegrateWise Owns — Our Layer\n\n| Component | Description |\n| --------------------- | ----------------------------------------------- |\n| Memory Core | Personal, conversational, organisational memory |\n| Intelligence Platform | Structured data, entities, lineage |\n| Governance Rail | Approvals, promotion, policies, audit |\n| Twin / Reasoning | AI that reads over memory and generates insight |\n| View Layer | Dashboards, signal monitor, executive view |\n| MCP Server | The global connector to external systems |\n\n### Customer Owns — Their Layer\n\n| Component | Description |\n| ------------------------ | -------------------------------------------------------------- |\n| Execution infrastructure | Agents, workflow runners, automation |\n| Tool runtime | Open WebUI, Agent Zero, n8n, Zapier, internal tools |\n| AI models | Their own model deployments (or proxied through IntegrateWise) |\n| Workflow orchestration | How tasks get done |\n| Agent systems | Autonomous agents that act on behalf of users |\n\n**Why this boundary:** Execution infrastructure is expensive to host, hard to generalise, and already exists in the customer's stack. Memory is the layer nobody else owns. By staying on the memory side, IntegrateWise remains lean, affordable, and focused on the unique value nobody else provides.\n\n---\n\n## 2. The Architecture\n\n```\n┌─────────────────────────────────────────────────────────┐\n│ INTEGRATEWISE │\n│ │\n│ ┌─────────────────────────────────────────────────────┐ │\n│ │ Memory Core │ │\n│ │ Personal · Conversational · Organisational │ │\n│ │ Intelligence Platform · Lineage · Entities │ │\n│ └─────────────────────────────────────────────────────┘ │\n│ │ │\n│ ┌───────────┼───────────┐ │\n│ │ │ │ │\n│ ┌───────────┴──┐ ┌────┴─────┐ ┌──┴──────────────┐ │\n│ │ View Layer │ │ Twin / │ │ Governance │ │\n│ │ │ │ Reasoning│ │ Sidebar │ │\n│ │ Dashboards │ │ │ │ │ │\n│ │ Signal Mon. │ │ Reads │ │ Approvals │ │\n│ │ Exec View │ │ memory, │ │ Insights │ │\n│ │ Workbench │ │ generates│ │ Suggestions │ │\n│ │ │ │ insight │ │ Promotion │ │\n│ └──────────────┘ └──────────┘ └─────────────────┘ │\n│ │\n│ ┌─────────────────────────────────────────────────────┐ │\n│ │ MCP Server — Global Connector │ │\n│ │ Reads · Writes · Events · Memory-aware actions │ │\n│ └────────────────────────┬────────────────────────────┘ │\n└──────────────────────────┼──────────────────────────────┘\n │\n ┌───────────────┼───────────────┐\n │ │ │\n ┌───────┴──────┐ ┌──────┴──────┐ ┌─────┴───────┐\n │ Customer's │ │ MCP Bridges │ │ Any MCP- │\n │ Agent Stack │ │ for Legacy │ │ Compatible │\n │ (Zero, OWUI) │ │ (CRM, etc.) │ │ Tool │\n └──────────────┘ └─────────────┘ └─────────────┘\n Customer owns Bridges for Ecosystem\n execution non-MCP tools builds\n```\n\n---\n\n## 3. Component Definitions\n\n### 3.1 Memory Core\n\nThe canonical layer. A single source of truth for the organisation's intelligence. **This is the product.**\n\n| Component | What It Does | Persistence |\n| --------------------- | ------------------------------------------------- | --------------------------------------- |\n| Personal Memory | Per-user private notes, preferences, bookmarks | Permanent. Private to user. |\n| Conversational Memory | Full conversation threads with context | Permanent. Private to user. Searchable. |\n| Organisational Memory | Promoted insights, shared knowledge, SOPs | Permanent. Shared with team. |\n| Intelligence Platform | Structured data — accounts, departments, entities | Permanent. Governed. |\n| Lineage | Every data point traceable to its source | Immutable. |\n\n**Key property:** Memory is the layer nobody else owns. CRM vendors own CRM data. Support vendors own tickets. But nobody owns the cross-system, persistent, governed memory that ties it all together. That's IntegrateWise.\n\n---\n\n### 3.2 Twin / Reasoning Layer\n\nThe AI that reads over memory and generates insight. It does not execute workflows. It does not replace the customer's agent stack. It reasons.\n\n| Capability | Description |\n| ------------------------ | ----------------------------------------------------------- |\n| Natural language queries | Ask questions about accounts, signals, trends, and memory |\n| Insight generation | Proactive recommendations from cross-domain analysis |\n| Context surfacing | Relevant memory projected into the workbench automatically |\n| Multi-model reasoning | Switch between AI models without losing context |\n| Lightweight actions | Propose tasks, notes, promotions — governed, not autonomous |\n\n**Principle:** The Twin generates the _what_. The customer's execution stack handles the _how_.\n\n---\n\n### 3.3 Governance Sidebar\n\nA collapsible right-side panel in the workbench. Surfaces what needs attention without requiring a separate interface.\n\n| Section | What It Shows |\n| --------------- | --------------------------------------------------------------------- |\n| Approvals | Actions proposed by the Twin that need human review before proceeding |\n| Insights | New signals, predictions, and cross-domain correlations |\n| Suggestions | Recommended actions based on current context |\n| Promotion Queue | Working-layer findings ready to be promoted to organisational memory |\n\n---\n\n### 3.4 View Layer\n\nProjections of memory. Read-only. Every team member sees the same truth through a role-specific lens.\n\n| View | Purpose |\n| ---------------------- | ------------------------------------------------------------------- |\n| Account Dashboard | Portfolio health, risk indicators, KPIs |\n| Intelligence Dashboard | Live signals, predictions, correlations |\n| Executive View | Board-level health, one-number view |\n| Signal Monitor | Real-time alerts across all domains |\n| Memory Explorer | Browse and search all three memory layers |\n| Workbench | The primary interface — Twin chat + dashboards + governance sidebar |\n\n---\n\n### 3.5 MCP Server — Global Connector\n\nThe universal bridge between IntegrateWise and the customer's ecosystem. One protocol, infinite connections.\n\nMCP plays three roles:\n\n1. **Standard ingress/egress** — for tools, apps, and data sources\n2. **Common protocol** — for memory-aware actions across systems\n3. **Thin bridge** — between governed context and user-owned execution\n\n| MCP Function | Direction | Examples |\n| -------------------------- | --------- | ----------------------------------------------------------- |\n| Read from external tools | Inbound | Pull CRM data, support tickets, product metrics into memory |\n| Write to external tools | Outbound | Create tasks, update records, send notifications |\n| Emit events | Outbound | Signal detected, health changed, memory promoted |\n| Expose memory as MCP tools | Outbound | Customer's agents can query IntegrateWise memory via MCP |\n\n**What MCP is not:** It is not an execution runtime. It is not a workflow engine. It does not replace the customer's automation stack. It is a protocol-level bridge — thin, stateless, and universal.\n\n---\n\n## 4. What Is Explicitly Out of Scope\n\nIntegrateWise does not build, host, or maintain:\n\n| Out of Scope | Reason |\n| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |\n| ✕ Workflow orchestration engine | The customer uses n8n, Zapier, Temporal, or their own system. |\n| ✕ Agent runtime / autonomous agents | The customer uses Agent Zero, AutoGPT, LangGraph, or their own system. |\n| ✕ AI chat interface / Open WebUI | The customer uses Open WebUI, ChatGPT, or their own system. |\n| ✕ Full execution of complex multi-step workflows | IntegrateWise handles lightweight, governed actions. Multi-step orchestration belongs to the customer's stack. |\n| ✕ Hosting the customer's AI models | Enterprise can bring private models. IntegrateWise proxies, not hosts. |\n\n**Why these are out of scope:** Hosting execution infrastructure creates a cost structure that customers won't pay for when they already have their own stack. By staying lean on the memory side, IntegrateWise remains affordable and focused.\n\n---\n\n## 5. How the Pieces Connect\n\n### Why the Unit Economics Work\n\nExecution infrastructure is expensive to host: VPS, Docker, Workers, Redis, Spine DB, R2, KV, D1 — and that's just for memory and intelligence. Double it for execution: workflow runners, action queues, retry logic, rollback handlers, error monitoring, per-action compute.\n\nThe customer already pays for n8n. Already pays for HubSpot workflows. Already pays for Jira automation. If IntegrateWise adds execution on top, they pay IntegrateWise **and** continue paying for the tools they already use. Twice for the same capability. Worse — our version has less coverage than tools they've been using for years.\n\nMemory doesn't have this problem. Nobody is paying anyone else for cross-system, governed, persistent institutional memory. That bill doesn't exist yet. IntegrateWise creates a new line item, not a duplicate of an existing one.\n\n### MCP Appears Twice\n\nMCP is at both ends of the loop. It is the bridge in both directions.\n\n**Inbound — data ingestion:**\n\n```\nExternal Tool (HubSpot, Jira, Stripe, ...)\n │\n ▼\n MCP Server ── universal connector, reads from tool\n │\n ▼\n Loader ── fetches raw data\n │\n ▼\n Normalizer ── 8 stages, canonical schema\n │\n ▼\n Spine ── stores canonical entities\n```\n\n**Outbound — intelligence + lightweight writeback:**\n\n```\n Spine\n │\n ▼\n Twin ── reads memory, generates insight, proposes\n │\n ▼\n View Layer ── dashboards, Entity 360, signals\n │\n ▼\nGovernance Sidebar ── proposals, approvals\n │\n ▼\n Human ── approves or acts in native tool\n │\n ▼ (if lightweight action approved)\n MCP Server ── writes back to external tool\n │\n ▼\nExternal Tool (task created, record updated)\n```\n\n### The Full Loop\n\n```\nTool → MCP → Loader → Normalizer → Spine → Twin → View → Governance → Human → MCP → Tool\n │ │\n └──────────────────────── memory compounds, loop continues ─────────────────────────┘\n```\n\nMemory compounds with every pass through the loop. After a month, the Spine knows the business. After six months, it is institutional memory. The loop is the moat.\n\n### A Typical Flow\n\n1. **Data enters via MCP** — CRM data, support tickets, product metrics flow into the Intelligence Platform through the global connector.\n2. **Memory is enriched** — data is normalised, deduplicated, cross-referenced, and stored in the canonical layer with full lineage.\n3. **Twin reasons** — the reasoning layer detects signals, generates insights, and surfaces them in the view layer.\n4. **Governance surfaces** — the right-side sidebar shows approvals, insights, and suggestions to the user.\n5. **User acts (or approves)** — the user can approve a proposed action, which writes back through MCP to the external tool.\n6. **Customer's agents query memory** — the customer's autonomous agents read context from IntegrateWise via MCP, execute in their own stack, and write results back.\n\n### The Workbench\n\n```\n┌──────────────────────────────────────────────────┐\n│ │\n│ WORKBENCH GOVERNANCE │\n│ SIDEBAR (right) │\n│ ┌──────────────────────────┐ ┌──────────────┐ │\n│ │ │ │ │ │\n│ │ Twin chat │ │ Approvals │ │\n│ │ Inline insights │ │ Insights │ │\n│ │ Dashboard widgets │ │ Suggestions │ │\n│ │ Signal feed │ │ Promotions │ │\n│ │ Memory context │ │ │ │\n│ │ │ │ (collapsible)│ │\n│ └──────────────────────────┘ └──────────────┘ │\n│ │\n└──────────────────────────────────────────────────┘\n```\n\n---\n\n## 6. Principles\n\n| # | Principle | Description |\n| --- | ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| 1 | **Memory is the product** | Persistent, governed, cross-system memory is what nobody else provides. Everything else supports memory. |\n| 2 | **Don't compete with the customer's stack** | If they already have agents, workflow runners, and AI interfaces, don't rebuild those. Connect to them. |\n| 3 | **Execution is expensive, memory scales** | Hosting execution infrastructure creates cost the customer won't pay for. Memory has predictable costs and high margins. |\n| 4 | **One connector, not twenty** | MCP as the universal protocol replaces the need for native connectors to every tool. One server, infinite connections. |\n| 5 | **Lightweight actions, governed always** | IntegrateWise can propose and execute simple actions. Complex orchestration belongs to the customer's stack. All actions go through the governance rail. |\n| 6 | **The Twin reasons, it doesn't execute** | The Twin reads memory and generates insight. It tells you _what_. Your execution stack handles _how_. |\n\n---\n\n## 7. What We Sell\n\n### Buyer Gets\n\n| What | Description |\n| ---------------------------- | ------------------------------------------------------------------------ |\n| Persistent, governed memory | Three layers. Always-on. Cross-system. Survives people and time. |\n| Intelligence Platform | Structured data across accounts, departments, and entities. |\n| Twin (reasoning over memory) | AI that reads your memory, surfaces insights, proposes actions. |\n| Governance sidebar | Approvals, insights, and suggestions — always visible, never in the way. |\n| Dashboards and views | Role-specific projections of canonical state. |\n| MCP global connector | One protocol to connect everything. No per-tool integration cost. |\n| Lightweight governed actions | Create tasks, update records, send notifications — approval-aware. |\n\n### Buyer Does NOT Get\n\n| What | Why |\n| ------------------------- | ---------------------------------------------------- |\n| Hosted workflow engine | They already have one. |\n| Hosted agent runtime | They already have one. |\n| Hosted AI chat interface | They already have one. |\n| Full autonomous execution | Too expensive to host. Too risky without governance. |\n\n---\n\n## 8. Naming\n\n| Name | Is | Is Not |\n| ---------------------- | --------------------------------------------------------- | ----------------------------- |\n| IntegrateWise | The memory and governance platform | An execution platform |\n| Intelligence Platform | The canonical memory layer | A workflow engine |\n| Twin | Reasoning layer over memory | An autonomous agent |\n| Hermes | The Twin's reasoning engine (skill-based, model-agnostic) | An execution engine |\n| MCP / Global Connector | Universal bridge to external systems | A runtime or hosted service |\n| Governance Sidebar | Right-side panel for approvals and insights | A separate workbench |\n| Workbench | The single user interface | Multiple separate workbenches |\n\n---\n\n## 9. Summary\n\nIntegrateWise is a memory-first platform. It provides persistent, governed, cross-system memory that no single tool vendor owns. It connects to the customer's existing execution stack through a universal MCP-based connector. It surfaces insights and governance through a lightweight workbench with a collapsible sidebar. It does not attempt to replace the customer's agents, workflow runners, or AI interfaces.\n\nThis architecture keeps IntegrateWise lean, affordable, and focused on the unique value that nobody else provides: **the layer where institutional knowledge lives, persists, and compounds.**\n\n---\n\n_Document: IntegrateWise Architecture v2.0_ \n_Author: Nirmal, Founder_ \n_Scope: Internal reference. Source of truth for product, docs, marketing, and pricing._ \n_Supersedes: All previous architecture descriptions._\n"}