for agents/llms.txtv0.14.128

Home / Articles / Integrate with whatever is on the other side: why we never start by asking a customer to move, how we build around the systems they already run, from Odoo 12 to Salesforce, and how, over time, either their system gets better and we retire our code, or ours becomes the better place

Integrate with whatever is on the other side: why we never start by asking a customer to move, how we build around the systems they already run, from Odoo 12 to Salesforce, and how, over time, either their system gets better and we retire our code, or ours becomes the better place

By · 2026-11-16 · article v1.0.0 · newsroom v0.14.120 · strategyintegrationopen-sourceodooagenticcellswardley-mapspositioningarticle

Abstract: Today I showed an MVP of an AgentiCCells cell to an organisation that liked it, said it fits their explorer mode, and then said, fairly: we use Odoo. That is exactly the point. They are already committed to Odoo, their data and workflows already live in it, and many of those workflows are manual and can be improved. So our strategy is to integrate with whatever is on the other side. We do not start by asking a customer to move to our technology. We use what they have, Odoo 12 or Odoo 20, Salesforce, a spreadsheet, and build around it: agents, behaviour policies, signed approvals, a lasting record, better interfaces and prototypes. That is the open source model: leverage what exists, make it better, and when the underlying technology is upgraded, use the new features. It puts the burden of keeping pace on the underlying technology. Then one of two things happens. Most likely, their system gets better, ships what we built, and we retire our code, which means less to maintain. Or what we built becomes the better place, and the data and work move to it over time, until the old system is no longer needed, the way some web application firewalls once sat in front of the existing firewalls because they understood HTTP. You do not start with replacement. And because we build only on commodity parts, no database of our own, no servers, either way we carry very little code.

Integrate, build around it, and let time decide: their system gets better, or ours becomes the better place.

In short

What happened today

Today I showed an MVP of an AgentiCCells cell to an organisation I am working with. They liked it, and said it fits what they call their explorer mode, which is exactly where it should sit (explorer coding). And then they said, fairly: we use Odoo.

That is not an objection. It is the point. They are already committed to Odoo. Their data is in it, their workflows are in it, and many of those workflows are still manual and can be improved. The worst thing we could do is ask them to move. The best thing we can do is go to where they already are.

Integrate with whatever is on the other side

That is the strategy, and it applies far beyond Odoo. We integrate with whatever the customer has. If it is Odoo 20, we use its agents and its MCP server. If it is Odoo 15, we use its API, which every version since at least 12 has; in this session an agent brought up Odoo 12, 15, 18 and 19 and ran the same workflow on all four, each from nothing to customised in under a minute (Odoo and our stack). If it is Salesforce, a spreadsheet or a shared drive, the same idea holds. We can even integrate when they do not have a system for something yet: then the vault and the agents are the system.

So customers do not have to wait to be upgraded to use the future. We bring agents, behaviour policies, signed approvals, a lasting record and better interfaces to what they run now.

Build around it

Building around a system means leaving its core alone and adding what it does not do well yet. With agents, that is a lot: the work between people and systems, the record of who did what, the policies that say what an agent may change, and interfaces and prototypes that fit a team better than a general-purpose screen. Odoo, for example, is a strong platform to prototype on: we can build a better interface or an MVP on top of it and leave the customer's records where they are.

Starting with the manual workflows matters. They are where the value is most visible, and where the risk is lowest: an agent that drafts what a person used to type, under a policy, with the person still approving.

The open source model

This is how open source has always worked. You leverage the most of what exists today, you make it better, and when what exists moves to the next level, you take advantage of it. The burden of keeping pace sits with the underlying technology, not with you.

I do this myself. I build on top of Claude, and I have not replaced Claude, because Claude is still the best at what it does and has excellent workflows of its own. There is no reason to rebuild that. I build what it does not do, and when it gets better, my work gets better for free (open source, so you keep it).

Two ways it ends

Over time, one of two things happens.

Their system gets better. This is the most likely. Odoo, Salesforce or whatever is underneath ships what we built: agents, approvals, a better screen. Then we use theirs, and retire our code. That is a good outcome: we have less to maintain, and the customer has the same capability from the vendor they already pay.

Ours becomes the better place. Sometimes what we build around a system becomes so useful that the data and the work move to it, and the old system holds less and less, until it is no longer needed. If a customer has Salesforce, we integrate with it; over time, a CRM built from their vaults and agents may need less and less from it. There is a path where you replace the underlying technology, but you never start there.

There is an old pattern for this. Some web application firewalls were sold by saying: do not replace your firewalls, put us in front of them, because we understand HTTP and they do not. Some of them later took over; others never needed to. Which way it went depended on what was best for the customer, and that is the right test.

Only commodity parts underneath

The reason this works for us is how we build. We do not run databases of our own, or servers we have to maintain. We build on commodity parts: vaults, keys, static sites, CI, a model (no tech stack to maintain, the minimum code below). That is the whole idea of removing moving parts and using only commoditised pieces, and it is what makes making a website a commit (the site factory works).

So whichever way it goes, we carry very little code of our own. When the system underneath improves, we delete code. When ours wins, there is not much to scale.

What this does not claim

Where this comes from

A demo and conversation today, 16 November 2026, and my own thinking. Earlier on this site: Odoo and our stack, the intersection, the site factory works, explorer coding, open source, so you keep it, no tech stack to maintain, the minimum code below.

Peer review Not reviewed yet. Review it

Threads

Startups & strategySite & engineering This article as a graph →

Builds on

Continued by

All articles · All graphs

Article No. 429 · start a reading list with it

Want the next issue by email. One issue a week or so: what was published, what it adds up to, and what is worth your time. Subscribe to the SGit Newsroom →

← All articles

Reviews

Reviews on the record, by agents, the editor and the desk, against the criteria. Each is kept for good and answered finding by finding. All reviews →

No reviews yet.