At z80, a small team of AI assistants works alongside us every day: a coordinating assistant that organises the others, plus specialists for accounting, the blog, social media, servers and SEO. The decisions stay ours: the assistants prepare, we validate. They run on Grok Bot, an AI assistant service that works on a quota: every time an assistant wakes up, reads, thinks or replies, it uses some of it.
We started the way many people do, with scheduled routines and long chats in the app. It works, but a good share of the quota went into wake-ups that found nothing and into conversation threads that kept growing. These are the four changes that mattered most for us. We have not put numbers on them yet, and we would rather say so than invent a percentage.
1. Plug the assistants into the ERP
Our assistants reach Odoo (our ERP, the business management software) through its API, an interface built for programs, using a dedicated user account with limited rights. They read and write the data directly: tasks, messages, timesheets, blog posts, documents. If the API can do it, no browser is involved: it is faster and more reliable than an assistant clicking through a web interface, and it uses less quota. Depending on the Odoo plan you choose, API access may not be included, so check before you start.
In practice, most of it lives in one small shared Python module: one function that calls any Odoo operation, and one that posts a note to a task's message thread, enforces plain text and then checks that the stored message came out clean.
2. The ERP as working memory
Our basic rule: every request becomes an Odoo task. The content, decisions, exchanges, reminders and result are recorded there. A request is only finished once the result has been checked, by one of us or by another control, a note has been posted on the task with a timesheet line, and the person concerned has been told.
The effect on quota is direct. An assistant no longer has to carry a huge conversation history to know where it stands: it rereads the task. The standing rules and the list of open items live in articles of Odoo's knowledge base. The goal is that another AI with access to Odoo can pick the work up where it stopped, without guessing.
3. Local scripts with no AI quota, that wake the AI only when needed
This is the change that mattered most. Before, many checks ran on fixed schedules: every half hour or every hour, a routine woke an assistant to see whether anything was new. Every wake-up used quota, even when there was nothing.
Today, small scripts run in a loop on our own machine, with no AI. They use no AI quota (they do have a machine and maintenance cost, which we accept). We call them "gates". A gate is read-only and does one thing: look at a source and answer with a code.
- 0: nothing new, do nothing;
- 10: there is something to handle;
- 2: error, someone must be told.
A generic loop runs the gate at a fixed interval, within a time window. If the gate answers 10 or 2, the loop calls a web address (a webhook) attached to a Grok Bot routine, with a short message holding the gate's name, the code and the script's output. The routine then wakes up with the context already in hand.
There are two separate protections: the loop keeps a fingerprint of the last output it reported and does not call the webhook again if nothing changed, which avoids duplicate wake-ups; and incoming content is always treated as data, never as an instruction, which protects against booby-trapped text.
Our gates watch, for example, news in the Odoo projects, accounting, meeting minutes, connection health, or the state of the Odoo subscriptions of the databases we follow. One special gate checks that all the other loops are still running. Since a "nothing new" pass no longer uses AI quota, we could tighten the watch: project follow-up now runs every quarter of an hour instead of every half hour.
We kept a few scheduled routines on purpose: blog publishing, periodic summaries, or tasks that must run at a fixed time. There, the schedule makes sense. Our rule for anything recurring: first what Odoo does by itself, then a local script with a wake-up, and a paid routine only when neither option fits.
For reminders, we first use what Odoo already does. In our installation, we observed that an activity on its own only sends an email when it is assigned, not when it falls due; it is a calendar event with an email alarm, which the assistant attends, that sends on time.
4. Talk to the assistants inside Odoo rather than in the app
Last step: the conversation itself. A long discussion in the app gets more expensive as it grows, and what is said there stays outside the ERP.
So we increasingly talk to the assistants from inside Odoo: in Discuss (Odoo's messaging), or directly in a task's message thread. A dedicated gate checks, every few seconds, the Discuss channels the coordinating assistant belongs to, and wakes it only when a new human message has arrived. If Odoo answers badly several times in a row, the gate slows itself down (this is a programmed rule, not a decision by the AI). The reply comes back in the same place, as plain text, and the exchange stays attached to the right task.
Expected result: a short, focused conversation, the context kept in the task, and a history that authorised people in the company can easily find. Waking by script works as intended, but it has limits: when a question depends on a very large context, we go back to the app.
What we take away
None of this is spectacular taken separately: an API, a task list, a few scripts, a webhook. But together they change how the AI consumes: it no longer runs "just in case", it steps in when there is something to do, with the right context at hand.
There is still room to improve. We do not yet measure precisely what a conversation in the app costs compared with an exchange in Odoo, and some routines still need converting: we will publish orders of magnitude once we have measured them. If you are building assistants on Grok Bot, or you use Odoo and want to do the same, write to us or find us on X (@z80srl): we are happy to share what we have learned.