AI assistant for trades: 2026 playbook

AI assistant for trades: 2026 playbook

“AI assistant” shouldn’t mean “random chatbot that sometimes makes things up”. For a trade business, it should mean:

• A reliable intake flow that captures the right details.
• A clear approval step (human or rule-based).
• An audit trail (who said what, what was created, when).
• One system of record for customers, jobs, and invoices.

This playbook shows how UK trade teams are using AI in 2026 for real outcomes: faster quote turnaround, fewer missed appointments, and less time chasing money.

The 5 workflows that pay back fastest

1) Call intake → job card (without missing details)

Most lost jobs happen before you even send a quote: bad notes, wrong address, no photos, no access notes.

AI does well:

• Ask the same questions every time (postcode, access, parking, urgency, photos).
• Summarise the call into a clean job description.
• Tag the job by type (“boiler breakdown”, “EICR”, “storm damage”).

Human still owns:

• Booking promises (“we’ll be there in 30 minutes”).
• Price commitments.
• Safety / compliance sign-offs.

If you want the AI to create the customer + job automatically, connect it to Toolfy via ChatGPT Apps/MCP (Toolfy supports Authorization: Bearer <PAT> + Idempotency-Key on write calls).

2) Quote drafting (faster, not cheaper)

AI helps you ship quotes faster by turning messy intake notes into clear scope + assumptions.

What to automate:

• Rewrite scope in plain English.
• Add exclusions and access assumptions.
• Add 2–3 upsell suggestions (only as suggestions).

What not to automate:

• Final price.
• Whether VAT applies.
• Contract wording that creates liability.

If you run fixed-price menus, pair this with a price book and keep the AI away from totals.

3) Dispatch + scheduling triage

Most “AI scheduling” tools are really just prioritisation + routing.

Minimum viable AI dispatch:

• Score jobs by urgency and revenue risk.
• Suggest the best tech based on skill + location.
• Draft the customer message (“tech en route, ETA 2:10pm”).

In Toolfy, keep it simple:

• Store skills as tags (e.g., “gas-safe”, “ladder-work”, “EICR”).
• Store job type as a category and urgency as a field/tag.
• Let AI suggest assignments; a dispatcher approves the final schedule.

4) Invoice + payment link (same day, every time)

You don’t need AI to “do invoicing”. You need it to remove the friction:

• Draft invoice notes and “work completed” summaries from job photos/checklists.
• Suggest the correct payment ask (“pay now by card”, “bank transfer ok”).
• Trigger a payment link immediately after completion.

Toolfy already makes “get paid today” a default workflow; use AI to speed up the wording and consistency, not the accounting.

5) Payment chasing + review requests (without awkwardness)

The best follow-ups are short, specific, and consistent. AI makes that repeatable.

Automate the drafting:

• “Friendly nudge” (day 1 overdue)
• “Second nudge + options” (day 7 overdue)
• “Final notice” (day 14+ overdue)
• “Paid → review request”

Keep the policy human-owned:

• When you stop work.
• When you send a letter before action.
• When you write off bad debt.

Two implementation modes (pick one)

Mode A: AI drafts, humans approve (recommended)

Best for solo owners and small teams. You keep control, but you still remove 80% of the admin.

Example:

1. Customer calls → transcript created.
2. AI produces a “job card draft”.
3. Office checks it for errors → clicks “Create job”.

Mode B: AI executes tools (guardrails required)

Best when you already have stable processes and you want speed at the edges (after-hours intake, high volume, seasonal spikes).

Guardrails that matter:

• Use Toolfy Idempotency-Key on every write (POST/PATCH).
• Pass x-agent: chatgpt so logs and rate limits attribute automation traffic.
• Limit scopes (e.g., customers:write, jobs:write, no admin/billing scopes).

Toolfy setup checklist (10 minutes)

1. Create a Personal Access Token in Toolfy (scoped to the workflow).
2. In your AI tool, store:
   • Authorization: Bearer <PAT>
   • x-org-id (if you manage multiple workspaces)
   • x-agent: chatgpt
3. For any write endpoint, generate a unique Idempotency-Key per user action.

For the full header list and API surface, see the Toolfy ChatGPT Apps quick start: https://help.toolfy.io/help/integrations/chatgpt-apps

Prompt pack (copy/paste)

Prompt: call intake → structured job card

You are the dispatcher for a UK trade business.
Ask only the questions required to create a job card.
Output JSON with: customer_name, phone, email, address, postcode, job_type, urgency, access_notes, photos_requested, description, preferred_dates.
If something is missing, ask a single follow-up question.

Prompt: quote scope rewrite (no pricing)

Rewrite the job scope in plain English using UK spelling.
Do NOT invent details. Use only the notes provided.
Include: what we will do, what we won't do, assumptions, what the customer needs to prepare, and 2 optional upgrades.
Return as bullet points.

Prompt: payment reminder (firm, polite)

Write a 3-sentence payment reminder for an overdue invoice.
Tone: calm, professional.
Include the invoice number, amount, and payment link placeholder.
Offer 2 options: pay now or reply with a date for payment.

What to measure (so this isn’t “AI theatre”)

• Quote turnaround: % of quotes sent same-day.
• AR days: time from invoice sent → paid.
• No-show rate: confirm reminders reduce wasted travel.
• Admin hours saved: weekly time in “paperwork” before/after.
• Rework incidents: track “AI got it wrong” and fix the intake questions.

FAQs

What’s the biggest risk with AI in a trade business?

Letting it invent facts. Solve this with structured intake, strict “don’t guess” prompts, and a human approval step.

What’s the easiest place to start?

Quote drafting + payment reminders. They’re low risk, high frequency, and immediately measurable.

Do I need a developer?

Not for the first version. Start with AI drafting and humans approving. If you want tool execution, Toolfy’s ChatGPT Apps/MCP surface is designed for ops teams with guardrails (scopes + idempotency).