# FlowWink

FlowWink — The Business Operating System

> **The Business Operating System — operable by any agent. Ships with one.** > > A modular, self-hosted SaaS platform whose every capability is exposed as a skill over **MCP**. Run it with the built-in vertically-integrated operator **FlowPilot**, swap in an external one like **[OpenClaw](https://www.clawable.org)**, mix several in parallel — or run it as a pure SaaS with humans in the loop. The platform doesn't care. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) [![Release](https://img.shields.io/badge/release-v1.3.0-brightgreen)](https://github.com/magnusfroste/flowwink/releases) --- ## Vision > **Every business will have an agentic operator. FlowWink is the operating system it runs on — and it lets you bring your own operator.** ## Mission > **Give every business a self-hosted, fully-featured SaaS platform that any agent can operate via an open protocol — with a great default operator included, and the freedom to swap it out for whatever the agent ecosystem produces next.** --- ## A new kind of business software For decades, business software has been a collection of tools you operate manually — CMS, CRM, ERP, email, e-commerce — each requiring human input at every step. **FlowWink is a Business Operating System (BOS):** a unified, modular platform where every module (66 across CMS, CRM, commerce, finance, HR, operations) exposes its capabilities as **agent skills over MCP**. An operator — local or external — turns those skills into autonomous business outcomes. You set the direction. The operator runs the business. You choose which operator. --- ## The Operator Layer — bring your own brain ``` ┌──────────────────────────────────────────────────────────────┐ │ FlowWink SaaS Platform (always on, agent-agnostic) │ │ • 68 modules · 600+ MCP-exposed skills │ │ • Database + RLS · Automations · Event bus · Workflows │ │ • MCP server — the universal surface for any operator │ └──────────────────────────────────────────────────────────────┘ ▲ │ any combination, swap freely │ ┌──────────────────────────────────────────────────────────────┐ │ Operators (opt-in, interchangeable) │ │ • FlowPilot — local, vertically integrated, included │ │ • OpenClaw — external, community-driven (clawable) │ │ • Claude Desktop · Salesforce · Microsoft · Oracle · custom │ └──────────────────────────────────────────────────────────────┘ ``` | Profile | Recommended operator | |---|---| | SMB, no agent stack, wants "it just works" | **FlowPilot** (built-in) | | Already runs OpenClaw / Claude Desktop / custom MCP | **External**, FlowPilot off | | Wants belt-and-braces — local heartbeat + external power | **Both**, on the same skill catalog | | Pure SaaS, humans in the loop | **Neither** — modules work without an agent | All four are first-class. Disabling FlowPilot does **not** reduce what FlowWink can do — every skill is still callable over MCP, every automation still fires. See [`docs/concepts/operator-strategy.md`](docs/concepts/operator-strategy.md) and [`docs/architecture/mcp-as-platform.md`](docs/architecture/mcp-as-platform.md). > **Why this matters:** the rationale for letting traditional SaaS be orchestrated by agents — and the architecture that makes it work — is the subject of the **[Agentic Handbook (clawable)](https://www.clawable.org)**. FlowWink is the reference implementation. --- ## What FlowPilot does FlowPilot is not a chatbot, a copilot, or a content suggester. It is an **autonomous agent** — a persistent process that wakes up on a configurable schedule (default: every 6 hours), reads your business situation, and acts. ``` ┌─────────────────────────────────────────────────────────────────┐ │ THE AUTONOMOUS LOOP │ │ │ │ Evaluate → Plan → Advance → Propose → Automate → Reflect │ │ ↑ │ │ │ └─────────── Remember ← ──────────────────────────┘ │ └─────────────────────────────────────────────────────────────────┘ ``` | What FlowPilot does | How | |---------------------|-----| | Writes and publishes blog posts | Researches topics, drafts, SEO-optimizes, schedules | | Qualifies and enriches leads | Scores, enriches from domain, routes to deals | | Sends newsletter campaigns | Segments subscribers, drafts, schedules sends | | Manages product promotions | Creates landing pages, promotional posts | | Triages support tickets | Auto-categorizes, routes, resolves from Knowledge Base | | Reviews deal pipeline | Surfaces stale deals, drafts re-engagement | | Proposes new objectives | Reads site stats, spots gaps, creates its own goals | | Works alongside the agents you bring | Claude, ChatGPT, Cursor, OpenClaw and others operate the same instance over MCP, each as its owner | | Evolves its own capabilities | Creates new skills, updates its instructions, reflects | --- ## Modules — 66 integrated domains FlowWink has a **modular architecture where each module owns its data, skills and UI** (tables, views and skill seeds). Modules register via `defineModule()` with typed contracts. | Category | Modules | |----------|---------| | **Content** | Website (Pages), Blog, Knowledge Base, Docs, Wiki, Handbook, Media Library, Templates, Forms, Site Migration | | **CRM & Sales** | Contacts, Companies, Deals, Quotes, Sales Intelligence, Customer 360, Business Identity, Visitor Intelligence | | **Commerce** | E-commerce, Point of Sale, Bookings, Subscriptions, Inventory, Pricelists, Returns / RMA, Shipping, Manufacturing (MRP-light) | | **Finance** | Accounting (BAS 2024 / IFRS / US GAAP), Quotes & Invoicing, Expense Reporting, Reconciliation, Purchasing, Fixed Assets, Multi-Currency | | **HR & People** | HR & Employees, Payroll, Recruitment, Consultants, Timesheets, Contracts, Documents | | **Operations** | Projects, Field Service, Maintenance, Approvals, SLA Monitor, Calendar, Surveys & NPS | | **Communication** | Email Router, Newsletter, AI Chat, Live Support, Tickets (Kanban + auto-triage), FlowWork, River, Webinars, WebMeet, Voice | | **Data & Growth** | Flowtable (agent data layer), Analytics, Paid Growth | | **System & Operator** | FlowPilot, Agents (connected over MCP), Browser Control, Composio, Developer | Every module is enabled by the **FlowWink Platform** template — since the edge surface was consolidated behind `agent-execute`, turning a module on costs skill rows and navigation, not deployment slots. Each module provides: - **Data layer** — Supabase tables + RLS policies + RPCs - **Admin UI** — React pages under `/admin/` - **Skill seeds** — capabilities auto-registered into `agent_skills` and exposed over MCP - **Webhook events** — `module.action` signals on the platform event bus Composite MCP groups (`marketing`, `sales`, `operations`, …) let an external operator request a curated toolkit with `?groups=marketing` — no need to know the internal taxonomy. --- ## Skills — 500+ capabilities, exposed over MCP | Domain | Sample skills | |--------|---------------| | **CMS & Content** | `manage_page`, `manage_blog_post`, `manage_kb_article`, `manage_global_block`, `migrate_url`, `scrape_url` | | **CRM** | `manage_leads`, `manage_companies`, `manage_deals`, `qualify_lead`, `enrich_company`, `process_signal` | | **Commerce** | `manage_product`, `place_order`, `record_pos_sale_v2`, `close_pos_session_v2`, `manage_subscription` | | **Finance** | `manage_journal_entry`, `import_bank_image`, `reconcile_transaction`, `auto_approve_vendor_invoice`, `book_expense`, `mark_paid` | | **HR & People** | `hire_application`, `auto_allocate_vacation`, `lock_timesheet_period`, `manage_contract`, `manage_employee` | | **Procure-to-Pay** | `generate_expense`, `submit_expense`, `approve_expense`, `book_expense`, `create_purchase_order`, `receive_goods` | | **Operations** | `manage_project`, `manage_task`, `manage_field_service`, `sla_check`, `dispatch_automation_event` | | **Communication** | `send_newsletter_campaign`, `manage_webinar`, `upload_document` | | **Support** | `triage_ticket`, KB-powered auto-resolve | | **Intelligence** | `search_web`, `extract_pdf_text`, `competitor_monitor`, `prospect_research` | | **Operator-internal** *(FlowPilot only, not MCP)* | objectives, soul, reflect, planning, specialist delegation | All skills follow Anthropic's MCP best practices: self-describing (`Use when:` / `NOT for:`), flat OpenAI-strict-mode-safe JSON Schemas, namespaced. See [`docs/architecture/mcp-as-platform.md`](docs/architecture/mcp-as-platform.md). --- ## Knowledge — one index, every surface **Most products bolt search on top of the systems. FlowWink has the memory built in — the same knowledge, different eyes, no extra product and no data leaving your instance.** Six content sources — pages, knowledge base, wiki, docs, handbook, documents — feed a single embedded index. Every grounded surface reads from it: | Who is asking | What they can retrieve | |---|---| | A visitor in the public chat | Public content only — published pages and KB articles | | Staff in FlowWork | Public *and* internal — wiki, handbook, documents, contracts, CRM | | An external agent over MCP | Whatever its key's scopes allow | Visibility is a property of the content, enforced by row-level security — not a filter the calling surface remembers to apply. A source whose module is switched off stops being indexed (nobody pays to embed content they turned off), and answers carry citations that link back to the record they came from. Retrieval is the default because it scales; when the index cannot answer — a brand-new instance, a page published a minute ago, no embedding key — grounding falls back to full text rather than to nothing. Degrade, never gate. See [`docs/architecture/retrieval-engine.md`](docs/architecture/retrieval-engine.md) and [`docs/architecture/conversation-and-retrieval.md`](docs/architecture/conversation-and-retrieval.md). --- ## FlowPilot — the included operator FlowPilot is FlowWink's **vertically-integrated, local autonomous operator** — one of many possible MCP consumers, but the one that ships in the box. It runs *inside* the platform's trust boundary, which gives it advantages no external operator can replicate: zero-config onboarding, direct DB/event access, brand-aligned defaults, predictable cost. External operators like **[OpenClaw](https://www.clawable.org)** instead win on velocity, plugin ecosystem and frontier reasoning. FlowWink supports both — see [`docs/concepts/operator-strategy.md`](docs/concepts/operator-strategy.md) for the honest trade-off. ### Heartbeat Protocol (7 steps) ``` 1. EVALUATE — Score past actions against real outcomes (traffic, leads, revenue) 2. PLAN — Decompose active objectives into executable steps 3. ADVANCE — Execute the next pending step for each objective 4. PROPOSE — If no active objectives, analyze stats and create new goals 5. AUTOMATE — Detect recurring patterns, suggest or create automations 6. REFLECT — Review recent actions, distill learnings 7. REMEMBER — Save insights to semantic memory for future cycles ``` ### Workflow DAGs — Multi-step automation chains ``` Research topic → Write blog post → Create social posts → Schedule newsletter s1 s2 s3 s4 {{s1.topic}} {{s2.post_id}} {{s3.content}} ``` - **Template variables** — `{{stepId.result.field}}` passes data between steps - **Conditional branching** — run a step only if a previous result meets a condition - **Failure modes** — `on_failure: continue` or `stop` per step ### Outcome Evaluation Loop FlowPilot uses **causal correlation** to connect actions to business outcomes: - Traffic metrics, leads, bookings, and revenue signals - Hard gates for technical failures (timeout, 429, auth errors) - Skill Scorecard — flags underperforming skills (>60% negative rate) - Learnings saved to semantic memory for the next planning cycle ### Multi-Agent Delegation FlowPilot delegates subtasks to specialist sub-agents with persistent sessions: ``` FlowPilot → delegate_task("seo", "analyze /pricing page") → delegate_task("content", "write a case study about...") → delegate_task("sales", "review stale deals > $10k") ``` Built-in specialists: **seo**, **content**, **sales**, **analytics**, **email** — each maintains conversation history across invocations. ### Skill Packs ``` skill_pack_install("E-Commerce Pack") → product_promoter, cart_recovery_check, inventory_report skill_pack_install("Content Marketing Pack") → content_calendar_view, seo_content_brief, social_post_batch skill_pack_install("CRM Nurture Pack") → lead_pipeline_review, deal_stale_check, customer_health_digest ``` --- ## Connect your agent — MCP FlowWink speaks one open protocol, in both directions: **MCP (Model Context Protocol)**. 600+ skills exposed as tools, resources like `flowwink://briefing`, a 3-tool dispatch mode (`search_skills` · `read_skill` · `execute_skill`) so a client's context stays small, and `?groups=marketing` to narrow to a department. ``` ┌─────────────┐ MCP ┌──────────────────────────┐ │ FlowWink │◄──────────────▶│ The agents people bring │ │ Platform │ tools/call │ • Claude / Claude Code │ │ (modules + │ resources │ • ChatGPT · Cursor │ │ 600+ skills)│ │ • OpenCode · Gemini │ │ FlowPilot │ │ • Copilot · Hermes │ │ built in │ │ • OpenClaw │ └─────────────┘ └──────────────────────────┘ ``` - **One key, one agent, one owner** — every connected agent acts as the person who connected it and never reaches further than their module access - **It knows who it is** — `flowwink://briefing` tells the agent its name, owner, mission and how to sign - **Connect in three questions** — `/admin/agents` (admins) or *My agents* (anyone with a role): what do you call it, which client, what is it for - **Audit loop** — QA findings from connected agents become platform objectives The former A2A transport was retired in October 2026 — see [`docs/operators/connect-your-agent.md`](docs/operators/connect-your-agent.md). --- ## Architecture FlowWink follows the **OpenClaw** agentic architecture — composable layers with clear separation of concerns: ``` ┌─────────────────┐ ┌──────────────────┐ ┌─────────────────┐ │ Gateway │ │ Brain │ │ Memory │ │ │ │ │ │ │ │ • Visitor chat │────▶│ • Pilot engine │────▶│ • pgvector │ │ • Admin operate │ │ (ReAct loop) │ │ semantic search│ │ • Webhooks │ │ • resolveAiConfig │ │ • Soul + Identity│ │ • Heartbeat │ │ • tool execution │ │ • Conversation │ │ • MCP gateway │ │ • trace IDs │ │ • Objectives │ └─────────────────┘ └──────┬───────────┘ └─────────────────┘ │ ┌────────────────┼────────────────────┐ │ │ │ ┌──────▼─────┐ ┌───────▼───────┐ ┌────────▼──────┐ │ Skills │ │ Heartbeat │ │ Workflows │ │ │ │ │ │ │ │ 600+ skills │ │ 7-step loop │ │ DAG chains │ │ Skill Packs │ │ Self-healing │ │ Conditions │ │ Connected │ │ Outcome eval │ │ Template vars │ └─────────────┘ └───────────────┘ └───────────────┘ ``` ### One reasoning core, all surfaces The Pilot engine (`_shared/pilot/`) is the single engine shared by every surface: - **`agent-operate`** — interactive admin sessions (streaming) - **`flowpilot-heartbeat`** — autonomous scheduled loop - **`chat-completion`** — visitor-facing AI chat - **`mcp-server`** — connected agents' calls, run as their owners No logic duplication. All surfaces get every capability automatically. ### Modularized core ``` _shared/ ├── pilot/ │ ├── reason.ts — Main ReAct reasoning loop │ ├── prompt-compiler.ts — System prompt assembly │ ├── handlers.ts — Built-in tool implementations │ └── built-in-tools.ts — Tool definitions ├── types.ts — Shared type definitions ├── ai-config.ts — Provider routing (OpenAI → Gemini → Local) ├── concurrency.ts — Lane-based locking ├── token-tracking.ts — Budget management ├── trace.ts — Correlation IDs (fp_{ts}_{rand}) └── domains/ └── cms-context.ts — CMS domain pack ``` ### Provider-agnostic, self-hosted first ``` OpenAI GPT-4o → Gemini 2.5 Flash → Local LLM (Ollama / LM Studio / vLLM) ``` FlowPilot routes to whichever provider is configured. Use your own API keys. Run fully offline with a local model. No vendor lock-in. --- ## What FlowWink replaces FlowWink draws inspiration from the best-in-class platforms across every business domain — and unifies them under one autonomous operator. | Category | Platforms that inspired | FlowWink's BOS module | |----------|----------------------|----------------------| | **Website** | WordPress, Webflow, Squarespace, Weebly | Visual block editor, 67 blocks, headless API | | **CRM & Sales** | HubSpot, Pipedrive, Salesforce | Leads, deals, companies — AI-qualified and enriched | | **Email & Marketing** | Mailchimp, Klaviyo, ConvertKit | Newsletter with autonomous segmentation and campaigns | | **Booking** | Calendly, Acuity | Service bookings with AI follow-up | | **Support** | Zendesk, Freshdesk, Intercom | Tickets + live chat with AI triage from Knowledge Base | | **Content & Copy** | Jasper, Copy.ai, Surfer SEO | FlowPilot writes, optimizes, and publishes into CMS | | **Automation** | Zapier, n8n, Make | Workflow DAGs with conditional branching | | **E-Commerce** | Shopify, WooCommerce | Products, orders, inventory, Stripe checkout | | **Finance** | QuickBooks, Xero, FreshBooks | Invoicing, double-entry accounting, expenses | | **Time Tracking** | Toggl, Harvest, Clockify | Timesheets with project-based tracking | | **ERP** | Odoo, ERPNext | Modular architecture — 66 domains, one platform | | **Headless CMS** | Contentful, Storyblok, Strapi | REST + GraphQL content API, multi-channel delivery | **The difference:** those platforms give you tools. FlowWink gives you an operator that *uses* the tools. One operating system. One operator. Self-host free. --- ## Tech Stack | Layer | Technology | |-------|------------| | Frontend | React 18, Vite, TypeScript, Tailwind CSS | | UI Components | shadcn/ui, Radix UI | | Backend | Supabase (PostgreSQL + pgvector, Auth, Storage, Edge Functions) | | Agent Engine | Deno edge functions, OpenAI function-calling format | | Editor | Tiptap | | State | TanStack Query | | AI Providers | OpenAI, Google Gemini, Local LLM (Ollama / LM Studio / vLLM) | | Agents | MCP over Streamable HTTP (one key, one agent, one owner) | --- ## Self-Hosting FlowWink is **free to self-host**. Your agent, your data, your infrastructure. ### Two-factor authentication for staff Every staff account can enroll an authenticator app (TOTP — Google Authenticator, Microsoft Authenticator, 1Password, Bitwarden, Apple Passwords), and an instance can require it of all staff (Users → Two-factor authentication). Enforced in the database, not only on the screen: a staff session without the second factor reads as nobody until it has it. Customers in the portal are not gated; agents through the MCP gateway have their own dials. Details: [docs/operators/mfa.md](docs/operators/mfa.md). ### Telemetry — one daily ping, one switch A running instance sends **one ping a day** to `https://www.flowwink.com`: a random instance id (minted on the first ping), the site URL and name, the skills version and which modules are enabled. Nothing else — no customers, no content, no numbers. That is how the project knows how many instances run the platform and which version they are on. The same endpoint takes the feedback you post from Admin → Feedback (bug reports, feature requests), with the same version attached so a report reads with its context. Switch it off in one place: **Admin → Feedback → "Share usage with the endpoint"**, or `FEEDBACK_SHARE_USAGE=false` in the edge function environment for an instance nobody will open the admin of. Point the endpoint at your own instance and the same module becomes the feedback board for *your* product. Details: [docs/operators/telemetry.md](docs/operators/telemetry.md). ### Quick Start ```bash git clone https://github.com/magnusfroste/flowwink.git cd flowwink npm install cp .env.example .env # Edit .env with your Supabase credentials npm run dev # migrations run automatically ``` ### Deploy without a CLI — fork, Vercel, Supabase, done The recommended path for a new instance needs **no local tooling at all** — three dashboards and a push. Proven end-to-end on a fresh instance: 630+ migrations, 77 edge functions, storage, cron and a working public site, zero terminal commands. 1. **Fork this repo** and create a [Vercel](https://vercel.com/) project from your fork. 2. **Create a [Supabase](https://supabase.com/) project.** From Project Settings → API Keys, copy the **Project URL** and the **publishable key** (`sb_publishable_…`). 3. **Set two Vercel env vars** — `VITE_SUPABASE_URL` and `VITE_SUPABASE_PUBLISHABLE_KEY` — then redeploy. (An unconfigured deploy shows a "connect your backend" page instead of a blank screen, so you always know where you are.) 4. **Pair Supabase's GitHub integration** with your fork and pick the production branch. It applies every pending migration and deploys every edge function declared in `supabase/config.toml` on each push. *Pairing alone may not fire it — push a commit if nothing happens.* 5. **Log in.** On a virgin instance the first account automatically becomes admin. 6. **Open the admin once** — skills come from the module seeds, not migrations, and the admin shell syncs them against the deployed artifact on load (Modules → "Sync skills from code" forces it). 7. Install a template, add an AI provider key, and (optionally) mint an operator key for an external agent. Full walkthrough, the verification queries, and the known first-run retry: **[docs/operators/provisioning-without-cli.md](docs/operators/provisioning-without-cli.md)**. ### Operations — how updates reach a running instance A site is **four layers**, each with its own delivery rail. The CLI-free stack moves three of them with a single fork sync: | Layer | Source of truth | How it updates | |-------|-----------------|----------------| | **Schema** | `supabase/migrations/*.sql` | Fork sync → Supabase GitHub integration applies pending migrations | | **Edge functions** | `supabase/functions/*` | Same push — every function declared in `config.toml` redeploys | | **Frontend** | this repo | Same push — Vercel rebuilds | | **Skills** | `src/lib/modules/*` (`skillSeeds`) | automatic on the first admin visit after the edge deploy (`sync_skills_from_code`); Admin → Modules → "Sync skills from code" forces it | The fourth layer is the one to remember: migrations never touch `agent_skills`. The sync button re-runs the module bootstrap from the freshly deployed bundle, refreshing every skill definition while leaving runtime `trust_level` overrides alone. It checks whether a newer build is live and reloads first, so a stale tab cannot write stale seeds. Migrations are **forward-only by construction**: a CI gate blocks any migration timestamped at or below the current head, because a back-dated file is silently skipped by the ledger on instances already past it — the drift class this repo learned the hard way. ### Running it yourself with the CLI Prefer terminal tooling, or maintaining several instances at once? ```bash supabase link --project-ref supabase db push supabase functions deploy --project-ref # Sync skill metadata from code into agent_skills (the step that prevents drift). DATABASE_URL='postgresql://postgres:@db..supabase.co:5432/postgres' \ npm run sync:skills -- --apply ``` Multi-site operators: **[docs/operators/provisioning-and-updates.md](docs/operators/provisioning-and-updates.md)** covers the fleet runbook, the `sync:skills` tool and fork vs. auto-deploy topology. See **[docs/guides/deployment.md](docs/guides/deployment.md)** for the full walkthrough. --- ## Documentation Start at **[docs/start-here.md](docs/start-here.md)** — the curated entry point that routes to operators, builders, agents and reference material. | Document | What it covers | |----------|---------------| | **[docs/modules/flowpilot.md](docs/modules/flowpilot.md)** | FlowPilot agent reference — skills, heartbeat, tools | | **[docs/reference/skills-source.md](docs/reference/skills-source.md)** | Skill registry — all registered skills | | **[docs/reference/module-api.md](docs/reference/module-api.md)** | Module contract system, typed schemas, plugin architecture | | **[docs/concepts/openclaw-law.md](docs/concepts/openclaw-law.md)** | Agentic architecture laws | | **[docs/concepts/prd.md](docs/concepts/prd.md)** | Product requirements — modules, capabilities | | **[docs/concepts/elevator-pitch.md](docs/concepts/elevator-pitch.md)** | BOS positioning, vision, competitive landscape | | **[docs/guides/setup.md](docs/guides/setup.md)** | Supabase setup, environment variables, migrations | | **[docs/guides/deployment.md](docs/guides/deployment.md)** | Supabase Cloud + Vercel deployment walkthrough | | **[docs/operators/provisioning-without-cli.md](docs/operators/provisioning-without-cli.md)** | Stand up an instance with dashboards only — fork, Vercel, Supabase GitHub integration, and how updates flow afterwards | | **[docs/operators/provisioning-and-updates.md](docs/operators/provisioning-and-updates.md)** | Multi-site provisioning, the update runbook, skill-sync & drift prevention | | **[docs/operators/local-development.md](docs/operators/local-development.md)** | Run Supabase locally (OrbStack/Docker) to validate migrations & changes before prod | | **[docs/builders/README.md](docs/builders/README.md)** | Architecture, extending the platform, writing skills | | **[docs/guides/security.md](docs/guides/security.md)** | RLS policies, auth patterns, security model | | **[docs/contributing/test-suite.md](docs/contributing/test-suite.md)** | Autonomous test framework (L1–L8) | | **[docs/concepts/a2a-communication-model.md](docs/concepts/a2a-communication-model.md)** | Agent-to-Agent federation protocol | | **[docs/pilot/](docs/pilot/)** | Pilot engine internals — architecture, handlers, reasoning | --- ## Roadmap - **Hosted Skill Pack Registry** — Import community skill packs from a manifest URL - **Workflow Visualization** — Admin UI to view and edit DAG steps visually - **Agent Marketplace** — Shareable FlowPilot configurations (soul + skills + workflows) - **FlowWink as MCP client** — purchasing negotiating price and volume with suppliers' agents, many at once --- ## Contributing Contributions are welcome. Open an issue or submit a pull request. See **[docs/contributing/contributing.md](docs/contributing/contributing.md)**. ## Learn More — The Agentic Handbook FlowWink is the reference implementation of a thesis: **traditional SaaS becomes radically more valuable when it's operable by agents over an open protocol**. The handbook explains why, how, and what patterns hold up in production. 📖 **[clawable — The Agentic Handbook & OpenClaw](https://www.clawable.org)** — Practical guide to building agentic systems, the OpenClaw operator, and the architectural laws FlowWink follows. Cross-references inside this repo: - [`docs/concepts/operator-strategy.md`](docs/concepts/operator-strategy.md) — Why FlowPilot is a *module*, not the core - [`docs/architecture/mcp-as-platform.md`](docs/architecture/mcp-as-platform.md) — The rule that keeps modules + MCP independent of any operator, and the MCP endpoints / auth / schemas / group-filter reference - [`docs/concepts/openclaw-law.md`](docs/concepts/openclaw-law.md) — The 10 inviolable agentic architecture laws ## License MIT — see [LICENSE](LICENSE) for details. ## Trademarks and independence Odoo is a trademark of Odoo S.A.; Salesforce, HubSpot, Shopify, NetSuite, ERPNext and the other product names in this README are trademarks of their respective owners. FlowWink is an independent project, not affiliated with or endorsed by any of them, and contains no code from them. Other products are named only to compare capabilities and to support migration. How we benchmark: [`docs/contributing/benchmarking-policy.md`](docs/contributing/benchmarking-policy.md). --- *Stop managing tools. Start directing outcomes. Bring your own operator — or use the one in the box.* **Made in Sweden 🇸🇪**