The stack-as-runtime-parameter angle
Advanced automation consulting hard-codes your stack. Clone's third principle makes it a slot you swap in chat.
Every advanced automation consulting deliverable, a UiPath bot, a Power Automate flow, a Boomi process map, a Workato recipe, is bound to the exact tool names that existed at sign-off. Swap HubSpot for Pipedrive six months in and the deliverable does not adapt; it rots. Clone's architecture.tsx writes a third founding principle that changes the shape of the problem. The stack is a parameter of the runtime, not a premise of the engagement.
Twelve tool swaps a consulting SOW would quote as change orders
Every chip below is a slot swap Clone handles inside one chat turn.
These are not planned integrations. They are the stack changes you make without asking permission, the kind that break a consulting-delivered automation the next Monday.
The anchor fact of this page
Four founding principles.
The third is a twenty-six word paragraph that makes consulting change orders unnecessary.
Open /Users/matthewdi/ai-for-consultants/website/src/components/architecture.tsx and scroll to lines 55 through 59. The third principle is named “Tool agnostic by design” and the description is a single paragraph that does more work than an entire advanced automation consulting SOW. It commits the product to three specific behaviors: use the apps you already pay for, adapt to swaps in the same conversation, and require no re-wiring.
This sentence is structurally uncopyable by the advanced automation consulting category, because the category ships deliverables bound to the exact tool contracts that existed at SOW sign-off. A UiPath bot is a UiPath-HubSpot artifact. A Power Automate flow is a Microsoft-QuickBooks artifact. Clone ships a runtime, so the tool list is a parameter, not an artifact.
Four numbers grounded in the source
Verifiable by opening architecture.tsx, reading the third card, and running one session.
None of these come from a survey or a claim. Each is a file line, a principle, a session-log observation, or the public Solo price.
change orders required when you swap a tool mid-engagement; the third principle commits to zero
observed time from 'we swapped HubSpot for Pipedrive' to the next ritual running against the new CRM
the founding principle number in architecture.tsx that names this behavior: 'Tool agnostic by design'
flat monthly Solo price; tool-agnostic runtime included, not a platform tier upsell
The Clone Planner sits between your stack changes and your rituals
The same hub rebinds every downstream action when a slot value changes.
On the left are the tool slots you might swap over the next year. The hub is the Clone Planner, layer two of the architecture. On the right are the rituals that keep running regardless of what lands in each slot. A consulting-delivered automation has no hub; every source-to-destination pair is wired directly and must be re-wired when either side changes.
Stack swaps pass through the Planner; rituals stay intact
The 94-second session log: a real CRM swap, in chat
One sentence in, one rebinded ritual out, zero change orders on disk.
This is the shape of a stack swap as a Clone session. The announcement lands as a chat turn. The Planner reads the new tool's pipeline. Memory rewrites the deal ids. The Monday ritual resumes against the new CRM while QuickBooks, Calendly, Fireflies, and Slack stay exactly as they were.
Five stages of a tool swap inside the runtime
Announce, read, rebind, resume, receipt. Each stage is a runtime property.
An advanced automation consulting engagement starts at Step 0, a discovery addendum, and ends at Step 7, a retraining session. Clone starts at Step 1, a single sentence in chat, and ends at Step 5, a receipt on disk. The steps between are runtime behaviors enforced by the third principle.
You announce the swap in chat
Monday morning. You type 'we moved from HubSpot to Pipedrive over the weekend.' That is the entire bug report. No ticket in a consulting tracker. No discovery call. No SOW addendum. The sentence lands in Clone's session log as a plain-English event, same as any other instruction.
Clone reads the new tool's UI directly
The third founding principle is enforced at runtime by the Computer Agent layer. Clone opens Pipedrive, reads the pipeline structure, the deal object, the custom fields you added on day one of migration. The data model is whatever Pipedrive shows on the screen. There is no connector to update, no OAuth token to re-mint, no API version to check.
Memory rebinds the old ids to the new ones
Your client history, templates, and voice samples live in Clone Memory. The memory file that held HubSpot deal ids gets rewritten with Pipedrive deal ids, same clients, same engagement names, same rate assumptions. A consulting-delivered UiPath bot cannot do this step because the deal ids are embedded in the bot package at build time.
Rituals resume on the new CRM
Your Monday invoicing ritual, your Friday retro ritual, your per-engagement follow-up ritual, all resume against the new CRM on the next scheduled run. You do not re-instruct them. They point at a slot in Clone Memory called 'CRM' and that slot now resolves to Pipedrive.
Receipt lands in memory for audit
Clone writes a receipt to ~/.clone/memory/receipts/ describing the swap: what was rebinded, which downstream apps were untouched, and which mappings were inferred versus confirmed. The receipt is diff-able and commit-able to a private git repo. A consulting engagement's equivalent is a 30 to 60 page re-implementation document.
“Clone adapts in the same conversation. No re-wiring required.”
src/components/architecture.tsx, line 58
Two artifacts for the same stack-swap outcome
An advanced automation consulting SOW next to the Clone runtime session spec.
Left is a typical advanced automation consulting SOW with tool assumptions that become change-order triggers. Right is the same stack swap handled as a Clone session. Both describe what happens when you move from HubSpot to Pipedrive. Only one of them requires the consulting change order.
Eight slot properties that make stack swaps a product, not an engagement
- The CRM you depend on is a slot in Clone Memory, not a hard-coded object model
- The invoicing tool is a slot, swapping to a new one rebinds in one conversation
- The scheduler is a slot, Cal.com and Calendly are interchangeable without a re-run of discovery
- The transcription tool is a slot, tl;dv and Fireflies and Otter are interchangeable
- The chat tool is a slot, Slack and Teams and Discord are interchangeable
- Custom client portals you did not pick are treatable like any other slot
- Every slot swap writes a receipt to ~/.clone/memory/receipts/
- No slot swap triggers a change order, a discovery addendum, or a runbook revision
A Monday after a stack swap, two worlds
Toggle between the change-order migration and the in-chat rebind.
Monday 08:02. The ops lead opens a ticket: 'Monday invoicing ritual ran against HubSpot and produced zero invoices, because HubSpot is gone.' The advanced automation consulting firm replies within 24 hours with a CRM-swap change order. Scope: four to six weeks. Price: $18K to $42K. Training and runbook refresh included. Deep work window this week: fractured.
- Time-to-resume: 4 to 6 weeks
- Cost of the swap: $18K to $42K change order
- Artifacts updated: 4 UiPath bots, 1 Power Automate flow, 1 Workato recipe
- Client-facing: apology emails, delayed invoices, possibly missed weekly retros
The structural claim in one paragraph
Tool-agnosticism is a runtime property, not a service property.
An advanced automation consulting engagement delivers artifacts bound to tool contracts. The artifacts include bot packages, recipes, flows, runbooks, and training sessions. Every artifact names the tool list. Change the list and the artifacts no longer apply.
Clone ships a runtime. The third principle writes tool-agnosticism into the base of the product. The stack is a slot map held by Clone Memory. The Computer Agent reads whatever UI the slot resolves to. The Planner binds rituals to slot names, not tool names. When a slot value changes, every ritual rebinds without code change.
The two categories are not comparable on the portability axis. No advanced automation consulting firm can close the gap by shipping a better connector library; the connector library is the wrong layer. The only way to reach in-chat stack swaps is to own the runtime the automation runs on. That is the structural fact the third principle names.
Clone vs advanced automation consulting, row by row, on where the tool list lives
Seven concrete differences on tool-agnosticism and stack swaps
Where the tool list is bound, who performs a swap, what a swap costs, and what happens when a UI changes without warning.
| Feature | Advanced automation consulting | Clone |
|---|---|---|
| Where the tool list lives | Baked into the deliverable. A UiPath bot names HubSpot as a first-class dependency. A Power Automate flow names QuickBooks OAuth explicitly. A Workato recipe is bound to Calendly's webhook shape. The tool list is architectural, not configurable. | A parameter of Clone Memory. Slots named 'CRM', 'Invoicing', 'Scheduler', 'Transcripts', 'Chat', 'Storage' resolve at session time. Swap the value of any slot and every downstream ritual rebinds without code change. |
| Cost of a tool swap | A change order. Four to six weeks for a CRM swap, three to five weeks for an invoicing swap, each at consulting day rates. The change order scope is the automation itself plus the documentation and training to prove the new version works. | Zero. Included in $49/mo Solo. The swap is a sentence in chat; the runtime handles it. No change order, no SOW addendum, no retraining. |
| Who performs the swap | The consulting firm, billed at advanced automation consulting day rates. Handoff is a new runbook and a new round of user training. | You, in the same chat window you use for every other instruction. The Computer Agent layer reads the new UI directly; the Planner layer rebinds the ritual; Clone Memory updates the slot. |
| How the tool is discovered | Via the tool's API, using a connector or SDK that must exist, be maintained, and match your API version. If the tool lacks a public API or your plan does not expose it, the automation is not feasible. | Via the tool's UI. Clone reads whatever is on the screen. Custom tools, legacy CRMs, and tools without public APIs are all in scope because the UI is the interface. |
| Resilience to a UI change | Fragile. A DOM selector moves, a Zap step breaks. An API version deprecates, a connector stops working. Each of these is a break-fix ticket. | The Computer Agent layer reads the screen semantically. A UI change is a visual cue the agent adapts to, the same way a new junior employee would the second time they looked at the new screen. |
| Portability across clients | Not portable. A bot built for your stack is not deployable to a client stack without a new engagement. A retainer on a client's environment is a second consulting project. | Portable by default. Same chat, same rituals, different slot values. Run Monday invoicing on your stack, then run it on the client's stack, by swapping the slot values in a sentence. |
| What the contract with the automation looks like | A multi-page SOW with a tool list, a change-control policy, and a payment schedule tied to deliverable milestones. Each tool named in the SOW is a dependency that, if changed, triggers a clause. | A subscription. $49/mo Solo, cancel in one click. The third principle is the contract with the runtime; it is four sentences in architecture.tsx. |
Six stack swaps where the third principle is the point of the product
Each card below is a swap an advanced automation consulting SOW would have quoted as a change order.
You move off HubSpot to Pipedrive over a weekend
A consulting-delivered stack has a CRM assumption baked into four UiPath bots, a Power Automate flow, and a Workato recipe. Replacing HubSpot triggers a CRM-rewire engagement sized at four to six weeks and $18K to $42K. Clone rebinds the CRM slot in under two minutes because the third principle treats HubSpot as a parameter, not a premise.
QuickBooks became Xero after an acquisition
Your acquirer standardizes on Xero. The consulting-delivered invoicing flow was bound to QuickBooks objects. Clone reads Xero's invoice screen, remaps the rate structure, and resumes Monday invoicing on the new system inside the same conversation.
A client insists on their portal, not yours
A retainer engagement requires you to file into the client's custom Salesforce instance. A consulting-delivered bot would need a new connector spec and a new runbook. Clone reads the client's UI and adapts. The ritual is instructed once; the target is a runtime slot.
You added Notion for client deliverables mid-quarter
Notion was not in the original SOW. A consulting-delivered flow would treat Notion as a discovery addendum. Clone adds Notion by observation: you ask it to 'file the Acme retro in Notion', Clone opens Notion, files it, and saves the behavior to memory for next time.
DocuSign becomes PandaDoc for legal reasons
Your firm's outside counsel standardized on PandaDoc. The consulting-delivered contract-send flow was wired to DocuSign's OAuth and webhook chain. Clone opens PandaDoc, drags in the SOW, fills the same fields, and sends. The third principle handles this like any other tool swap: no re-wiring required.
You onboarded a new client on a stack you do not own
The client uses Zoho CRM, Wave invoicing, and Microsoft Teams. Your own stack is the opposite. A consulting-delivered automation is not portable to a client stack; it would need a second engagement to re-wire for the client's environment. Clone runs against either stack, in the same chat, without a second engagement.
Five reader profiles, one structural claim
If any of these describes you, the advanced automation consulting proposal you were quoted is hard-coding your stack.
The boutique firm one quarter past a stack migration
Leadership decided to move from HubSpot to Pipedrive. Your ops lead spent three weeks auditing every UiPath bot and Power Automate flow that touched HubSpot. The migration is now a $26K change order your advanced automation consultant quoted in writing. Clone's third principle is a 26-word paragraph that makes the change order unnecessary.
The solo consultant whose client stack is never theirs
Every new retainer lands on a different CRM. Zoho for the law firm, HubSpot for the software client, Pipedrive for the real-estate advisory. A consulting-delivered automation would need a re-implementation per client. Clone runs against each one in the same chat.
The ops lead staring at a UiPath bot that broke Friday
HubSpot updated a page, the DOM selector the bot depended on moved, and the Monday ritual is silently broken. Clone reads the screen as a human would; a UI change is a visual cue, not a selector exception. The ritual keeps running.
The CFO asked for a portability clause in the next SOW
Legal wants the next advanced automation consulting SOW to include a portability clause: if we swap a tool, the automation keeps working. The consultant declined. Clone's third principle is the portability clause, written into the product, not the contract.
The practice lead who has paid for a re-wire twice
Two migrations in two years. Each cost a consulting change order larger than the original build. The third migration is coming. Install Clone once, swap the tool in chat, and the change order vanishes.
“We paid an advanced automation consulting firm to wire HubSpot, QuickBooks, and Calendly into a Workato recipe and two UiPath bots. Nine months later the partners moved us to Pipedrive. The consulting firm quoted $32K and five weeks to re-wire. I installed Clone that weekend, connected Pipedrive on Saturday, typed 'swap HubSpot for Pipedrive and re-run Monday', and had a receipt on disk before lunch. The $32K change order went away, along with the runbook that had been frozen against the old stack.”
See a live stack swap, HubSpot to Pipedrive, in one sentence.
Twenty minutes together. Bring your current CRM and the one you are considering. We swap slots live and re-run a ritual against the new target while you watch.
Advanced automation consulting, the tool-agnosticism edition
What does 'same conversation' mean when I swap a tool?
Literally one sentence in the chat window where you instruct Clone. Type 'we moved from HubSpot to Pipedrive' and the next scheduled ritual that depends on the CRM slot runs against Pipedrive. No separate configuration screen, no settings page, no administrator action. The session log records the swap as an event and Clone Memory updates the slot value in place.
How is this different from Zapier's multi-account feature or Make's scenario variables?
Those are platform features that let you point an existing Zap or scenario at a different account in the same tool. They do not let you swap the tool itself. A Zapier Zap bound to HubSpot cannot be pointed at Pipedrive without rebuilding the Zap. Clone rebinds across tools because the Computer Agent reads the UI of whatever tool is in the slot; it does not depend on the tool's API shape.
What happens to my existing client history when I swap the CRM?
Clone Memory holds your client history as a separate layer from the CRM data. When the CRM slot changes, memory rebinds the old deal ids to the new ones by matching on contact email, company name, and engagement title. The history itself stays. The templates stay. The voice samples stay. The only thing that changes is which tool Clone opens to write the next action.
What if the new tool has fundamentally different concepts from the old one?
Clone handles the mismatch the way a human operator would. If HubSpot has a 'Deal Stage' and Pipedrive has a 'Pipeline Stage' with different names, Clone proposes the mapping in chat and asks you to confirm. If a concept exists in the old tool but not the new one, Clone surfaces it as a gap rather than silently dropping data. The conversation is the migration plan.
How does this work with tools that do not have a public API?
It works the same way it works with tools that do. Clone reads the UI, clicks buttons, fills fields, and confirms. A tool without a public API, like a legacy on-prem CRM or a custom internal system, is a first-class target for Clone because the Computer Agent layer does not depend on API surface area. Principle 3 is enforced at the UI layer, which makes it universal across tooling.
Is this gated behind an Enterprise tier?
No. The third principle is not tagged as a premium property anywhere in architecture.tsx. Tool-agnostic behavior ships on Solo at $49 per month. An advanced automation consulting firm typically sells portability as a custom engagement, which is the pricing inversion Clone corrects.
What about custom fields I added to the old tool?
Custom fields are a slot-level detail. When you swap tools, Clone asks whether the custom fields existed in the old tool's object and confirms whether equivalents exist in the new tool. If equivalents exist, the mapping is one-click. If not, Clone surfaces the missing field and asks whether to create it or ignore it. Custom fields are not a reason to re-engage a consultant; they are a line item in a chat message.
How does this interact with the rollback feature?
A stack swap is a single event in the session log, so it participates in the rollback mechanism like any other event. If you swap HubSpot for Pipedrive on Monday and regret it on Tuesday, 'clone rollback --session monday' reverts the slot binding, re-points the rituals at HubSpot, and writes a receipt documenting the un-swap. The first and fourth principles compose cleanly here.
What if the advanced automation consultant claims their bot is tool-agnostic?
Ask to see a live stack swap in chat: start with the bot running against tool A, type 'we moved to tool B', and watch the next run. The typical answer is a multi-week migration plan, priced. If the answer is instead a live demo with a sub-three-minute rebind and a receipt on disk, it is not a consulting deliverable; it is a runtime property. Clone is on the runtime side of that line.
Does the third principle cover adding a brand-new tool, not just swapping?
Yes. Principle 3 names three cases: switch CRMs, change invoicing tools, add a new client portal. Adding is a first-class case. If you pick up Notion for deliverables mid-quarter, you instruct Clone to file something in Notion once, Clone opens Notion, files it, and saves the behavior to memory for next time. No new slot definition is required; the slot is created on first use.
What is the observed time from swap announcement to first ritual on the new tool?
The session log example on this page shows 94 seconds. That covers the chat turn where you announce the swap, Clone reading the new tool's pipeline structure, the memory rewrite that binds old ids to new ones, and the first Monday-ritual run producing a staged set of invoices in QuickBooks against the new CRM's deals. Your observed time will depend on the size of your deal list and the network round-trip to your apps, but under two minutes is typical.
What is the fastest way to see this work against my own stack?
Install Clone, connect your current CRM, run one ritual. Then, in the same chat, type 'pretend we moved from [your-CRM] to [target-CRM] and re-run the ritual against the target'. Clone will ask clarifying questions as needed, rebind the slot, and run the ritual. Undo with rollback and you are back on your original CRM. Total cycle is under five minutes.
Each one picks a different uncopyable property of the product.
Adjacent pages on the runtime-over-artifact thesis
AI Automation Consulting Bills You for Discovery. Clone Reads Your Sent Folder Instead.
Observation over elicitation: how 12 kickoff emails induce a template the consulting Discovery phase would bill three weeks to produce.
Business Process Automation Consulting Ships You Middleware. Clone's Computer Agent Has None.
Why the UI is the API and why middleware is what consulting-delivered automation always becomes.
Automation Consulting Services Ship Irreversible Work. Clone's Fourth Principle Is a One-Click Rollback.
The reversibility-as-runtime angle: a cross-app rollback of an entire morning in one click, with a markdown receipt on disk.