Pinchy vs Limiq
Per its public site, Limiq is a permission and audit control layer you put in front of AI agents you build. Pinchy is the full platform: end users chat with governed agents that act in your business systems, through a web UI or Telegram, with per-agent permissions and an HMAC-signed, hash-chained audit trail built in. Both are self-hosted, and both publish their source under an open-source license. Limiq is the closest twin we have seen on the feature surface, and a different shape of product.
The Core Difference
Point the agents you build at Limiq. Each gets an Ed25519 identity and short-lived, scoped capability tokens, and every action passes a verify call that checks tool restrictions, spend limits and rate limits, then lands in a hash-chained log. The center of gravity is a guardrail in front of agents you already operate.
Pinchy gives you the governed agents, not just the rules around them. End users chat through a web UI or Telegram, agents act in Odoo, email, and more, and every action is permissioned and signed. The center of gravity is a product people use.
Both are self-hosted, both are open-source-licensed, both scope permissions per agent, both chain their audit events, and both publish their source. We do not pretend otherwise. The honest question is whether you need the control layer or the whole platform.
Side by Side
Figures as of 16 October 2026, taken from Limiq's public site (limiq.io) and its public repository (github.com/qurveai/limiq.io). Check Limiq for current details. Corrections welcome via GitHub issue.
| Limiq | Pinchy | |
|---|---|---|
| Center of gravity | Permission & audit control layer (self-described v0.x reference implementation) | Full governed-agent platform |
| License (core) | Apache 2.0 (permissive) | AGPL-3.0 (copyleft) |
| Per-agent permissions | Ed25519 agent identity; tool restrictions, spend & rate limits; short-lived capability tokens | Allow-list tools per agent (e.g. email_draft granted, email_send not) |
| Per-agent spend / cost limits | Yes | On the roadmap |
| Tamper-evident audit | SHA-256 hash chain per workspace | HMAC-SHA256 per row plus hash chain (since v0.8.0); built-in verifier, CSV export |
| Agents | Bring your own | Built in, on the OpenClaw runtime |
| End-user channels | Not the model | Web UI + Telegram |
| Business-system integrations | Not an integration platform | Odoo, email, Telegram, web search, knowledge base (indexed locally, answers cite their source) |
| Public source code | Public, Apache-2.0 (github.com/qurveai/limiq.io) | Public, AGPL (github.com/heypinchy/pinchy) |
| Self-hosted | Yes | Yes (first-class, GHCR images) |
Being Honest
Limiq's Apache 2.0 is more permissive than Pinchy's AGPL-3.0. If you plan to embed the control layer inside a proprietary product, Apache 2.0 avoids the copyleft obligations that AGPL carries. For some teams that alone is decisive.
If you have already built agents in your own framework and only want a permission, spend-limit, and audit guardrail in front of them, Limiq's focused control-layer shape fits that better than adopting a whole platform. Its verify call can answer ALLOW, DENY or PENDING_APPROVAL, and it ships JavaScript and Python SDKs.
Limiq advertises hard per-agent spend and rate limits now. Pinchy enforces tool allow-lists and a signed audit today, with cost budgets still on the roadmap. If spend caps are a hard requirement, that is a real point for Limiq.
Where Pinchy Wins
Pinchy gives you governed agents people actually use, not a guardrail you wire into agents you still have to build. The agents, the chat, the integrations, and the governance arrive together.
Pinchy ships a deep Odoo integration plus email (Gmail, Microsoft 365 or IMAP), Telegram, web search, and a document knowledge base. Agents query stock, create orders, draft email, book a receipt from a photo, all from chat, within the tools you grant.
End users reach Pinchy agents through a web UI or Telegram, no developer integration required. Non-technical teams use it directly.
Pinchy's full source is public under AGPL-3.0, which keeps the platform and any modified version open to its users. Limiq's source is public too, under Apache 2.0, so the difference is the license, not the visibility. For a tool that governs your agents and signs your audit trail, being able to read the code matters either way.
Pinchy has no approval prompt. The control is the grant: give an agent email_draft but not email_send, or Odoo read tools without write tools, and it cannot do the rest. An agent has no tools until an admin grants them. Limiq's verify call can return PENDING_APPROVAL; Pinchy draws the line earlier, at which tools an agent has at all.
The license key is validated offline and Pinchy sends no telemetry. What runs on your infrastructure stays on your infrastructure, air-gapped if you want.
Decision Guide
You already build your own agents and want a focused permission, spend-limit, and audit layer in front of them, or a permissive Apache 2.0 license to embed in a proprietary product. Limiq is a service you wire into agents you write.
You want the governed agents themselves: end users chatting with agents that act in business systems like Odoo, with per-agent tool grants and a signed, hash-chained record of every action. Pinchy is a server you run and a model you choose; your team uses it in the browser or Telegram.
Insist on self-hosting, a tamper-evident audit trail, and source you can actually read. Both products agree governance belongs at the runtime, not in a cloud you cannot inspect.
FAQ
They are close on the governance surface and differ in shape. Per its public site, Limiq is a self-hosted control layer you put in front of AI agents you build: it enforces per-agent tool restrictions, spend limits, and rate limits, and records a tamper-evident audit log. Pinchy is a full platform where end users chat with agents that act in business systems through a web UI or Telegram, with per-agent permissions and a signed, hash-chained audit trail built in. If you already have agents and want a permission and audit guardrail, Limiq fits. If you want the governed agents themselves, Pinchy fits.
Yes, both publish their source, under different licenses. Limiq is Apache 2.0, a permissive license that is friendlier if you want to embed the control layer in a proprietary product; its source is at github.com/qurveai/limiq.io (the GitHub links on limiq.io currently point to a path that returns 404). Pinchy is AGPL-3.0, a copyleft license that keeps the platform and any modifications open; its full source is at github.com/heypinchy/pinchy.
Not yet. Limiq advertises per-agent spend and rate limits today. Pinchy enforces per-agent tool allow-lists and a signed audit trail today; cost budgets per agent are on Pinchy's public roadmap, not shipped. If hard per-agent spend caps are a requirement right now, that is a genuine point in Limiq's favor.
Both are tamper-evident and both use a hash chain. Limiq keeps a SHA-256 hash chain per workspace over its audit events. Pinchy signs each audit row with HMAC-SHA256 and chains it to the row before (since v0.8.0). A built-in verifier recomputes every signature and link, and the log exports to CSV. Pinchy's log is tamper-evident, not tamper-proof.
Use Limiq when you have already built agents elsewhere and want a focused permission, spend-limit, and audit layer to put in front of them, or when a permissive Apache 2.0 license matters because you plan to embed it in a proprietary product. Use Pinchy when you want the full governed platform: end users chatting with agents that act in business systems like Odoo, with per-agent tool grants and a signed, hash-chained audit trail out of the box.
Self-host Pinchy yourself in minutes, or book a call to talk it through. Your choice.
Or email us: info@heypinchy.com