Pinchy vs Windmill
Windmill is a mature developer platform for turning scripts into flows and internal tools, with AI agent steps inside them. Pinchy is a chat-first agent platform where the agent is the product, with per-agent permissions and a signed audit trail. Both publish their core under AGPL-3.0. They answer different questions.
The Core Difference
You write scripts in Python, TypeScript, Go and more, compose them into flows, and build internal UIs. AI agents are one kind of step inside a flow you author. The audience is developers.
You describe a role: what the agent is for, which tools it may use, which data it can see. Team members chat with it directly in a web UI or Telegram. The audience is everyone, not just engineers.
Windmill's center is workflow orchestration: scheduling, triggers, retries, worker scaling. Pinchy's center is governed conversation: which tools each agent may use, and a record of what it did.
Side by Side
Figures as of 16 October 2026, taken from Windmill's public pricing, product and documentation pages. Check Windmill for current details.
| Windmill | Pinchy | |
|---|---|---|
| Primary primitive | Script / flow | Agent (role + tools + scope) |
| Primary audience | Developers | Whole team, non-technical |
| AI agents | Steps inside a flow | The top-level product |
| License (core) | AGPLv3 (CE binaries include proprietary code) | AGPL-3.0 |
| Permissions in free tier | Roles + path-based ACLs + folders | Roles + per-agent tool allow-list |
| Groups | Up to 4 in CE | Pro (€1,188/yr for up to 10 users, quote above) |
| Audit log | CE: 14-day default retention; EE: 365-day default and object-storage export; signing not documented | Every row HMAC-SHA256-signed and hash-chained, built-in verifier, CSV export, free |
| Human approval step | Approval steps in flows; forms, group-restricted approvers and no self-approval on EE | No approval step. Control comes up front: grant email_draft without email_send |
| Chat interface for users | Flow-as-chat mode | Yes, per agent (web + Telegram) |
| Workflow scheduling & triggers | Extensive: schedules, webhooks, Postgres, WebSocket, MQTT in CE; Kafka, NATS, SQS and cloud-queue triggers on EE | None: agents act on request only |
| Local models | Via custom OpenAI-compatible endpoints (Ollama documented) | Yes (Ollama), fully offline |
| Self-hosted | Yes | Yes (first-class, GHCR images) |
Being Honest
Scheduling, triggers, retries, approval steps, checkpoint and replay, horizontal worker scaling, multi-language scripts. If your problem is a robust pipeline, Windmill is purpose-built for it. Pinchy is not.
Years of development, a very high release cadence, around 18.2k GitHub stars (October 2026), and SOC 2 Type II under its Enterprise Edition. Pinchy is early-stage by comparison.
Item-level access control, folders, and workspace roles ship in the community edition. For a developer platform managing many scripts, that granularity is a real strength.
An internal-tool/UI builder plus a hub of prebuilt scripts. If you want to ship internal apps fast, Windmill covers more of that ground than Pinchy does.
Where Pinchy Wins
Team members talk to agents in plain language, in a web UI or Telegram. No flow to author, no script to write. The agent is built by an admin and used by everyone.
Each agent is a function: support drafter, bookkeeping assistant, knowledge guide. A bounded role is easier for a business to reason about than a growing graph of nodes.
Agents get no tools beyond their own workspace until an admin grants them, per agent; templates propose a starting set, and only admins create agents. Every tool call lands in an HMAC-SHA256-signed, hash-chained audit trail with a built-in verifier. To our knowledge, Windmill does not document cryptographic signing of its audit logs.
Pinchy's permission core and signed audit are AGPL and free, with no user limit. Several of Windmill's governance features (SAML/SCIM, more than 4 groups, exportable audit) sit behind the Enterprise Edition. Pinchy's own groups and agent visibility are Pro.
Pinchy agents read and write Odoo, draft and send email, search the web, and answer from the knowledge base with a cited source. No agent has tools beyond its own workspace until an admin grants them, so an agent can be given email_draft without email_send, or Odoo read tools without write tools. Every tool call lands in a signed audit trail.
Pre-built GHCR images, one-command Docker deploy, local models via Ollama, and no phone-home: the license key is validated offline. Pinchy asks you to run one Docker Compose stack and choose a model.
Decision Guide
Developers own the automation. The work is scripts and scheduled flows. You need triggers, retries, and worker scaling. AI is one step in a larger pipeline you control.
Non-technical people need to use AI agents directly. The agents act in business systems. Someone has to be accountable for who can do what, with a signed record.
Developers run Windmill for the heavy pipelines, and the team uses Pinchy agents for the conversational, judgment-heavy parts. They are separate systems with no built-in connection between them.
FAQ
They sit in different categories. Windmill is a developer-first workflow and script orchestration engine: you write scripts and flows, and AI agents are steps inside them. Pinchy is a chat-first AI agent platform for whole teams, where the agent is the top-level primitive with its own tools, roles, and audience. If developers build the automation, Windmill fits. If non-developers chat with agents that act in business systems under admin control, Pinchy fits.
Yes. Windmill added AI agent steps inside flows, with tool calling, MCP support, memory, and a flow-as-chat mode. The distinction is structural: in Windmill the agent is a building block inside a developer-authored flow. In Pinchy the agent is the product itself, configured by admins, used directly by team members through chat or Telegram.
Yes, Windmill's core is licensed under AGPLv3. The distributed community-edition binaries also contain some proprietary code, and several enterprise features (SAML/SCIM, unlimited groups, longer-retention and exportable audit logs) require the Enterprise Edition. Pinchy is AGPL-3.0 as well: its permission core — Admin/Member roles, the per-agent tool allow-list, and the tamper-evident signed, hash-chained audit trail — is free and self-hosted with no user limit. Groups, agent visibility and usage analytics are part of Pinchy Pro (€1,188/yr for up to 10 users, quote above).
Windmill's community edition includes a genuinely strong permission model: workspace roles, path-based item ACLs, and folders. It also keeps an audit log, with a default retention of 14 days per the docs (365 days on the Enterprise Edition). Object-storage export and SAML/SCIM require the Enterprise Edition, and the community edition is capped at 50 users and 4 groups. Windmill's pricing grid lists audit logs as "No" for the free tier, which differs from the docs, so check windmill.dev/pricing for current limits. Figures as of 16 October 2026.
Use Windmill when your team thinks in scripts and scheduled flows: data pipelines, internal tools, multi-language jobs, retry and checkpoint logic, horizontal worker scaling. Use Pinchy when non-technical team members need to chat with agents that take actions in tools like Odoo, with admin-controlled permissions and a signed record of every tool call.
Self-host Pinchy yourself in minutes, or book a call to talk it through. Your choice.
Or email us: info@heypinchy.com