Openpawz

<div align="center"> <img src="images/pawz-logo-transparent.png" alt="OpenPawz logo" width="200"> <br>

Your AI, your rules.

A native desktop AI platform that runs fully offline, connects to any provider, and puts you in control.

Private by default. Powerful by design. Extensible by nature.

English · 简体中文

</div>

---

Paws Overview

<div align="center">

Pawz In Action

https://github.com/user-attachments/assets/9bee2c08-ca86-4483-89a1-3eae847054b4

<br>

Engram Memory — Interactive knowledge graph with force-directed layout, flowing edge particles, and memory recall

https://github.com/user-attachments/assets/60b0f351-180e-49ed-a70b-e31556743949

<br>

Integration Hub — Community services via MCP Bridge, with category filters, connection health, and quick setup

<img src="images/screenshots/Integrations.png" alt="Integration Hub" width="800"> <br>

Fleet Command — Manage agents, deploy templates, and monitor fleet activity

<img src="images/screenshots/Agents.png" alt="Fleet Command" width="800"> <br>

Chat — Session metrics, active jobs, quick actions, and automations

<img src="images/screenshots/Chat.png" alt="Chat" width="800"> <br>

Pawz CLI — Full engine access from the terminal with zero network overhead

<img src="images/screenshots/PAWZ-CLI.png" alt="Pawz CLI" width="800"> </div>

---

Why OpenPawz?

OpenPawz is a native Tauri v2 application with a pure Rust backend engine. It runs fully offline with Ollama, connects to any OpenAI-compatible provider, and gives you complete control over your AI agents, data, and tools.

• Private — No cloud, no telemetry, no open ports. Credentials encrypted with AES-256-GCM in your OS keychain.
• Powerful — Multi-agent orchestration, 11 channel bridges, hybrid memory, DeFi trading, browser automation, research workflows.
• Extensible — Comm integrations via embedded MCP bridge to n8n's community node ecosystem, unlimited providers, community skills via PawzHub, local Ollama workers, modular architecture.
• Tiny — ~5 MB native binary. Not a 200 MB Electron wrapper.

---

The Integration Inversion

Every other automation platform locks integrations inside workflows. You must build a workflow before any tool is usable. OpenPawz inverts this — every integration is simultaneously a direct agent tool and a visual workflow node.

| | Zapier / Make / n8n (standalone) | OpenPawz | |---|---|---| | Tool availability | Locked inside workflows | Available directly in chat AND in workflows | | To use a tool | Build trigger → action chain first | Just ask your agent | | AI's role | One node inside the pipeline | The pipeline lives inside the agent | | Install a new package | Workflow node only | Instant chat tool + workflow node | | Community nodes | Manual sequential automation | AI-orchestrable via MCP bridge |

Install "@n8n/n8n-nodes-slack":

  n8n standalone:  available as a workflow node → must build a workflow to use it
  OpenPawz:        auto-deploys a workflow + indexes it for agent discovery
                   → "Hey Pawz, send hello to #general" — done

How it works: OpenPawz embeds n8n as an MCP server. n8n's MCP exposes three workflow-level tools: search_workflows, execute_workflow, and get_workflow_details. When you install a community package, Paw auto-deploys a per-service workflow (e.g. "OpenPawz MCP — Slack") that encapsulates the integration logic. The agent discovers workflows via semantic search and executes them via execute_workflow — all through the MCP bridge.

The insight: n8n's community nodes were designed for manual automation. OpenPawz makes them AI-native — Paw auto-deploys workflows that compose n8n nodes with credential binding, error handling, and retries. The agent decides which workflow to execute based on your intent, and only needs the visual Flow Builder when you want multi-step orchestration with branching, loops, or scheduling.

---

Original Research

OpenPawz introduces three novel methods for scaling AI agent tool usage and workflow execution. All are open source under the MIT License.

The Librarian Method — Intent-Stated Tool Discovery

Problem: AI agents break when they have too many tools. Loading thousands of workflow definitions into context is impossible, and keyword pre-filters guess wrong because they lack intent.

Solution: The agent itself requests tools after understanding the user's intent. An embedding model performs semantic search over the workflow index and returns only the relevant workflows — on demand, per round. We recommend a local Ollama model like nomic-embed-text for zero cost, but any embedding model works.

User: "Email John about the quarterly report"
  → Agent calls request_tools("email sending capabilities")   ← agent has intent
  → Librarian (embedding model): embeds query → cosine search → email_send, email_read
  → Only relevant tools loaded instead of every available definition

Key insight: The LLM forms the search query (it has parsed intent). A pre-filter on the raw user message would have to guess — the agent knows.

📄 Full case study: The Librarian Method

The Foreman Protocol — Low-Cost Tool Execution

Problem: When a cloud LLM executes tools, the reasoning around formatting and calling them burns expensive tokens. The actual API calls (Slack, Trello, etc.) are free or cheap — but the LLM processing around them is not.

Solution: A cheaper worker model executes all MCP tool calls instead of the expensive Architect model. The critical enabler is MCP's self-describing schemas — the MCP server tells the worker model exactly how to call each tool. No pre-training. No configuration. Any new n8n community node is instantly executable. We recommend a local Ollama model like qwen2.5-coder:7b for zero cost, but any model from any provider works.

Architect (Cloud LLM): "Send hello to #general" → calls mcp_slack_send_message
  → Engine intercepts mcp_* call
  → Foreman (worker model): executes via MCP → n8n → Slack API
  → Tool execution handled by the cheapest capable model in the stack

Key insight: MCP servers are self-describing. The worker model doesn't need to know how to use community integrations — MCP tells it at runtime.

📄 Full case study: The Foreman Protocol

The Conductor Protocol — AI-Compiled Flow Execution

Problem: Every workflow platform — n8n, Zapier, Make, Airflow — walks the graph node by node: sequential, synchronous, one LLM call per agent step. A 10-node AI pipeline with 6 agent steps takes 24+ seconds and 6 LLM calls. Cycles (feedback loops, agent debates) are structurally impossible — all require DAGs.

Solution: The Conductor treats flow graphs as blueprints of intent and compiles them into optimized execution strategies before a single node runs. Five primitives — Collapse (merge N agents → 1 LLM call), Extract (deterministic nodes bypass LLM entirely), Parallelize (independent branches run concurrently), Converge (cyclic subgraphs iterate until outputs stabilize), and Tesseract (partition graphs into parallel cells with per-cell memory isolation, synchronized at event horizons) — reduce a 10-node flow from 24s/6 calls to 4–8s/2–3 calls.

10-node flow, 6 agent steps:
  n8n / Zapier / Make: sequential walk → 24s+, 6 LLM calls
  OpenPawz Conductor:  compiled strategy → 4–8s, 2–3 LLM calls

Convergent Mesh (agent debate until consensus):
  n8n / Zapier / Make: impossible — DAG required
  OpenPawz Conductor:  bidirectional edges → iterative rounds → convergence

Key insight: n8n community nodes were designed for manual sequential automation. The Conductor makes them AI-orchestrable — describe a workflow in natural language, the NLP parser builds the graph, the Conductor compiles it, and the agents execute it. The entire n8n ecosystem becomes an AI-native automation engine.

📄 Full case study: The Conductor Protocol

Agent Execution Architecture — 5-Phase Optimization Pipeline

OpenPawz implements a 5-phase execution optimization pipeline that eliminates waste from the standard agent loop. Each phase is built, tested (162 dedicated tests), and wired into the live agent loop.

| Phase | Name | What It Does | Impact | |-------|------|-------------|--------| | 0 | Action DAG Planning | Model outputs a complete execution plan in one inference call; engine runs independent steps in parallel | 3–5× fewer inference calls | | 1 | Constrained Decoding | Provider-specific schema enforcement (OpenAI strict, Anthropic tool_choice, Gemini tool_config, Ollama format: json) | 0% parse failures | | 2 | Embedding-Indexed Tool Registry | Persistent SQLite tool embeddings with four-tier search failover (Vector → BM25 → Domain → Keyword) | <100ms tool discovery at 100K+ scale | | 3 | Binary IPC | MessagePack encoding for streaming deltas and plan results via EventBatcher and ResultAccumulator | 15–30% latency reduction | | 4 | Speculative Execution | CPU branch prediction for agents — learns tool transition patterns, pre-warms connections, predicts next tool | 200–800ms saved per prediction hit |

User: "Set up a weekly standup, invi