PatchBuddy. Get started
For Patchworks integration agencies

Build Patchworks integrations at the speed of conversation.

Describe what you need. PatchBuddy. builds the whole integration inside your Patchworks account. Endpoints, connectors, mappings, flows, error handling. You watch it build. You verify in Patchworks. You ship.

Get started See features
Build ShoppyShop Connector Live
logo.png 12 KB openapi.yaml 8.4 KB
Can you create a connector with endpoints for ShoppyShop using this API documentation and logo?
Got it. Parsed the spec. ShoppyShop API v2.4 with 11 endpoints. Setting up the connector with Bearer auth on api.shoppyshop.com.
Connector ready. 11 endpoints wired with auth, sensible retries, and the logo applied. You can use it in any flow now.
Connector · ShoppyShop 11 endpoints
ShoppyShop
api.shoppyshop.com · Bearer auth · v2.4
GET /products
GET /products/{id}
POST /products
GET /orders
GET /orders/{id}
POST /orders
PATCH /orders/{id}/fulfilments
GET /customers
GET /customers/{id}
POST /webhooks
DELETE /webhooks/{id}

Animation for representation of platform abilities only.

Built for Patchworks integration partners Shopify · NetSuite · Salesforce · BigCommerce · Magento · custom APIs
Why PatchBuddy

The boring parts of integration work, automated.

PatchBuddy is built for the patterns agencies repeat on every project. Senior developers stop spending their days clicking around a canvas. New hires ship integrations on day three.

Build by chat

Describe the integration. Watch every shape land in your Patchworks account.

Knowledge that compounds

Every gotcha, decision, and pattern is captured automatically. The next project starts where the last one ended.

Built for agencies

Multi-tenant from day one. Per-client isolation, team-level access controls, audit trail across every change.

How it works

The workflow, end to end.

Five stages from a fresh signup to a shipped integration with the patterns banked. Then repeat for the next client; the agent picks up where it left off.

  1. 01

    Set up an organisation

    Add your end-customer. Plug in their Patchworks API key once; everything from here is scoped per-org and never bleeds across clients.

  2. 02

    Plan the project

    Upload an SOW or describe the work in chat. PatchBuddy breaks the scope into a Discovery task plus the build tasks needed to ship, in order.

  3. 03

    Build the tasks

    Pick up each task in turn. The agent has full Patchworks access at task scope and builds, tests, and debugs alongside you.

  4. 04

    Wrap up

    Project summary, total cost, what shipped. Status flips to complete; everything stays in place for the next phase of work.

  5. 05

    Capture what was learned

    Patterns from this build land in project knowledge. Worth keeping across clients? Fork up to your agency tier so the next project starts with it.

The structure

More than a chatbot. Built like agency software.

Most AI integration tools are a chat box that forgets yesterday. PatchBuddy is shaped like the work itself — organisations, projects, tasks, each with its own focused chat.

Organisation
Acme Retail
Patchworks credentials access controls audit log
Project
Lightspeed K-Series Connector
Project chat: brief, planning, wrap-up
  • Discovery
    project chat
    Brief intake & task planning
  • Task
    task chat
    OAuth2 & token refresh
  • Task
    task chat
    Orders endpoint + cursor pagination
  • Task
    task chat
    Items endpoint
  • Task
    task chat
    Payments endpoint
Project
Shopify → NetSuite Sync
Project chat: SOW upload, planning, wrap-up
  • Discovery
    project chat
    Brief intake & task planning
  • Task
    task chat
    Order Flow
  • Task
    task chat
    Fulfilment Flow
  • Task
    task chat
    Returns Flow
What that gives you

Project structure does the heavy lifting.

AI plans the breakdown

Drop in a SOW or describe the brief in plain English. PatchBuddy proposes the project's tasks, you approve them in seconds. No staring at a blank Trello board wondering how to slice it.

Per-task focus

Each task has its own chat thread with its own context. Switching tasks doesn't bleed yesterday's connector debug into today's mapping work. The model picks up the right context for the new task.

Team-aware from day one

Assign tasks across the agency. Who's working what, where they got to, what's still open. Studio includes 5 seats; Agency is unlimited. Multi-seat is part of the structure, not a paywalled upsell.

Status that writes itself

Wrap-up generates from the tasks: what shipped, what got nudged, time and cost per task, models used, total project burn. Read it as a client report. Send it as one.

Lessons captured forward

Every wrap-up proposes knowledge entries from the build's interventions and gotchas. Approve the keepers — they go into your agency's knowledge fork. The next build against the same connector starts smarter.

Audit trail

Every model call, every credential use, every commit to the Patchworks tenant is logged against the operator who ran it. Defensible to a compliance review. Useful in a retro. Required when a client asks who did what.

Privacy by default

Your customer data, masked before AI sees it.

Personally identifiable information is replaced with locale-coherent fakes inside PatchBuddy, before it ever reaches an AI server. EU-hosted models on a per-turn toggle for the engagements that need it.

What the operator pastes Real 
{
  "customer_name": "Sarah Whitfield",
  "email":         "sarah@acmeretail.com",
  "phone":         "+44 7700 900482",
  "order_id":      "ORD-90218",
  "amount_gbp":    1249.50
}
What the AI receives Masked 
{
  "customer_name": "Helena Brookes",
  "email":         "helena.brookes@example.org",
  "phone":         "+44 7700 900318",
  "order_id":      "ORD-90218",
  "amount_gbp":    1249.50
}
On by default

Every new organisation has PII randomisation enabled out of the box. Toggle off only when a specific support task needs raw data.

Same map across the chat

The same real customer always maps to the same fake within an organisation. Multi-turn reasoning still works, the model isn't chasing a moving target.

System IDs preserved

Order IDs, SKUs, country codes, prices, timestamps. Untouched. The agent keeps the structural anchors it needs to debug a flow.

How privacy by default works
More than flows

Deliver Patchworks integrations end to end.

Flows are where most of the work lives, but they aren't the whole job. PatchBuddy covers the full delivery surface. Endpoints, connectors, mappings, scripts, runtime debugging, knowledge, audit, team handoff. Every step of an integration delivery, in one chat.

Live diagram

Watch every shape land.

A side drawer renders the flow shape-by-shape as PatchBuddy works. Real connections, real labels, real positions, the same view you'd see in the Patchworks canvas.

Trigger
Shopify webhook
→
Connector
NetSuite SO
→
Map
9 fields
Open knowledge

Read it. Fork it.

Platform defaults are open. Disagree? Fork to your agency or one client.

netsuite-create-pattern Platform
└─ cirql-override Agency
global-e-detection Platform
Multi-tenant

One agency. Every client.

Acme Outdoor Co. active
Fjord Apparel
Halla & Sons
+ 12 organisations
Auto-layout

Tidy as it grows.

Shapes auto-position as the flow changes. No canvas wrestling.

Cost transparency

No mystery bills.

Token spend is visible at chat, message, and turn level. Cache hit ratios, model selection, time-per-iteration. All on tap.

Turn cost
£0.0042
Cache hit
94%
Tokens
12.3k
Audit log

Every change captured.

14:32 flow.created · v3
14:38 cache.created · #142
14:51 connector.linked
15:02 flow.activated
One click

No "type yes to confirm"

Confirmation buttons render inline.

Forms

Structured questions

Connector
Shopify Production ▾
Entity
Order
Attachments

Drop in payloads.

Screenshots, sample JSON, HAR captures. All read.

JSON
HAR
Test runs

Verify before you ship.

Run with a real payload. Capture the response. Use it downstream.

✓ 200 OK 142 ms
"id": "SO-7821"
Multi-model

One chat. Every frontier model.

PatchBuddy speaks fluently across the major frontier providers. Pick the model that fits the task: Sonnet for the long build, Haiku for the quick lookup, Reasoner for the gnarly debug. Swap when the work shifts. One chat, every model, no console juggling between vendors.

  • You pick the model per task. Match it to the work, switch mid-flow if it changes shape.
  • Every frontier provider on tap. No copy-pasting between vendor consoles, no separate API keys.
  • Switch any provider on or off from the admin. For compliance, cost control, or when a vendor's having a bad week. Disabled providers get bypassed automatically.
  • Full cost transparency per provider, per turn, per token.
Anthropic
Claude family
OpenAI
GPT family
DeepSeek
Reasoner / V3
Moonshot
Kimi family
Mistral
Open-weights
Google
Gemini family
PatchBuddy.
Routing live

Stop building flows by hand.

Sign up, plug in your Patchworks credentials, ship your first integration tonight. No demo gate, no scoping call, no procurement detour.

Get started See pricing