- Home
- Apps
- SaaS Tools
- Custom AI Agent Builder (No-Code)
Illustrative previewA no-code configuration layer for Odoo that lets your team define, deploy, and monitor custom AI agents
— pick the model, write the behavior, bind it to real records — without touching Python. Built to order, installed, and supported by ECOSIRE.
What is Custom AI Agent Builder (No-Code)?
A no-code configuration layer for Odoo that lets your team define, deploy, and monitor custom AI agents — pick the model, write the behavior, bind it to real records — without touching Python. Built to order, installed, and supported by ECOSIRE. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your Odoo.
- 3
Go live + support
You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.
Technical Specifications
- Odoo Compatibility
- Odoo 17, Odoo 18, Odoo 19
- Editions
- Enterprise & Community
- License
- Licence confirmation required
- Python Requirement
- Python 3.10+
- Database
- PostgreSQL 12+
About this Product
Operations teams want AI on their own data — an agent that drafts a quotation follow-up from the sale.order, triages an inbound helpdesk.ticket, or summarizes a vendor account.move — but every one of those ideas today means a developer ticket. Odoo Enterprise 19 ships an AI field assistant and OpenAI-backed helpers, but they are point features tied to Odoo's own model choices; there is no place for a non-developer to say "here is my agent, here is its prompt, here are the records it can read, here is which LLM runs it." Native Odoo runs out of road exactly where you need to compose behavior: automated actions and server actions can call Python, but authoring, versioning, and cost-governing an LLM agent through the UI is not something the base product does.
This module adds that missing configuration layer. We build a new model (ecosire.ai.agent) whose records ARE your agents: each holds a display name, a provider/model selection (selection field spanning OpenAI GPT, Google Gemini, and Anthropic Claude), a system prompt and response-style config, a temperature/token budget, and a set of Many2one/Many2many bindings that scope which Odoo models and records the agent may read. Agents are authored in a clean OWL/XML backend view — no code, no server restart. At run time the agent is invoked from a smart button, an ir.actions.server automated action, or the JSON-RPC/XML-RPC API; the module marshals the bound record's fields into the prompt, calls the selected provider over HTTPS, and writes the response back to a linked record, a chatter message, or a mail.activity. Every call is metered: a computed cost field (@api.depends on token counters) and a per-agent usage log give operations a real spend view instead of a surprise invoice.
Security is first-class because agents touch real business data. Access is governed by ir.model.access.csv for the agent and log models plus ir.rule record rules so, for example, a sales agent is only ever bindable to sale.* records the invoking user can already see — the agent never becomes a privilege-escalation path around Odoo's own ACLs. API keys are stored as encrypted ir.config_parameter values, never in plaintext views, and outbound calls are gated so a misconfigured agent cannot exfiltrate fields outside its declared binding. QWeb templates render the optional agent-run report for audit.
Because this is a build-to-order product, we scope it to YOUR agents and YOUR models before we write a line of code. You tell us the first two or three agents you actually need (which app, which trigger, which output), we confirm the __manifest__.py dependency list and target Odoo version (17.0, 18.0, or 19.0; Community or Enterprise), and ECOSIRE builds, tests on a staging copy of your database, and installs it. There is no instant download — typical delivery is one working week from confirmed scope — and you receive the full source so you are never locked to us.
What you get
- Installable source code for your version of the module (pinned to your Odoo 17.0/18.0/19.0 and Community/Enterprise edition), yours to keep
- Installation and configuration on your environment, including provider API-key wiring via encrypted `ir.config_parameter`
- Technical documentation: model reference, security matrix (`ir.model.access.csv` + record rules), and the agent-invocation API
- End-user guide plus a live training session for the operations team who will author and run agents
- UAT on a staging copy of your database with a documented rollback plan before any production install
- Post-go-live support window for defect fixes and configuration questions
- Git repository handover with full commit history so your team (or any Odoo partner) can maintain it
- Initial set of 2–3 working agents configured against your real models and triggers as agreed in scoping
Who this is for
Operations lead automating repetitive work
Owns a backlog of manual, judgment-light tasks — follow-up drafts, ticket triage, document summaries — and wants to stand up bespoke AI agents against real Odoo records without waiting on a developer sprint for each one.
Odoo administrator / functional consultant
Configures the platform for the business and needs an AI layer that respects Odoo's ACLs and record rules, stores keys securely, and can be governed for cost — not a black box bolted onto the database.
Head of a department piloting AI internally
Wants to prove value with two or three targeted agents (sales, support, finance) before scaling, and needs per-agent usage and spend visibility to justify the budget and keep it under control.
IT/finance stakeholder governing AI spend
Must keep LLM costs predictable and auditable — needs per-agent metering, daily-spend guardrails, and an audit trail of what each agent read and produced across the company's models.
How Custom AI Agent Builder (No-Code) Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Delivery model | Built to order, installed and supported by ECOSIRE | You hire/assign a developer to build from scratch | Instant download, generic to everyone | Included in Odoo, no AI-agent layer to configure |
| No-code agent authoring | Ops users create agents in a backend form, no Python | Depends entirely on what your dev chooses to build | Rarely; usually fixed prompts or dev-config | None — server actions need Python code |
| Model choice (GPT/Gemini/Claude) | Per-agent `selection`, you bring your keys | Whatever your dev wires, extra work to add more | Often locked to one provider | Enterprise AI helpers tied to Odoo's provider choice |
| Security (ACLs / record rules) | `ir.model.access.csv` + `ir.rule`, honors user ACLs | Only as rigorous as the developer makes it | Generic access; may not match your rules | Odoo ACLs apply, but no agent-scoping concept |
| Cost & usage monitoring | Per-agent token log, `compute`d cost, spend guardrails | Must be specified and built, often skipped | Usually none or a coarse counter | None for LLM usage |
| Fit to your models | Bound to your real records in scoping | Fully custom but you carry all the effort | One-size-fits-all, adapt your process to it | N/A |
| Source & ownership | Full source + git repo handover, no lock-in | You own it but also own all the risk | Licensed binary/obfuscated, vendor-dependent | Core code, not customizable per agent |
| Odoo version support | Pinned to your 17.0/18.0/19.0, Community or Enterprise | Whatever your dev targets | Listed versions only, upgrades on their schedule | Ships with your Odoo release |
Frequently Asked Questions about Custom AI Agent Builder
Is this an instant download from the Odoo App Store?
No. This is a build-to-order product. ECOSIRE builds the module against your specific agents, models, and Odoo version, then installs and supports it. You do not download a pre-made app — you get a version tailored to your workflows plus the full source code.
How long does delivery take?
Typical delivery is one working week from confirmed scope. After a short scoping call we agree the first 2–3 agents, the target Odoo version and edition, and the manifest dependencies; then we build, test on a staging copy of your database, and install. Complex bindings or many agents can extend the timeline, which we confirm in writing before starting.
Which Odoo versions and editions are supported?
Odoo 17.0, 18.0, and 19.0, in both Community and Enterprise. The target version and edition are pinned in the module's `__manifest__.py` at build time. Enterprise-only dependencies are only used if your edition includes them; otherwise we build against Community-safe models.
Which AI models can the agents use?
Each agent selects its provider and model from a `selection` field covering OpenAI GPT, Google Gemini, and Anthropic Claude. You supply your own provider API keys, which are stored encrypted via `ir.config_parameter` — never in plaintext views. We can add or restrict providers per your security policy.
Is my data safe — can an agent read records it shouldn't?
No. Agents are scoped by explicit model/record bindings and governed by `ir.model.access.csv` plus `ir.rule` record rules, so an agent can only act on records the invoking user is already allowed to see. Outbound calls are gated to the declared binding, so an agent cannot exfiltrate fields outside its scope.
How do we keep AI spend under control?
Every agent run is metered. Token counters feed a `compute`d cost field and a per-agent usage log, and you can set per-agent rate limits and daily-spend guardrails so a runaway automated action cannot exhaust your provider budget. Operations gets a real spend view instead of a surprise invoice.
What about support and updates after go-live?
Delivery includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full git repository, your team or any Odoo partner can maintain and extend it. We also offer optional ongoing support and version-upgrade engagements (for example when you migrate to a newer Odoo release).
Can non-developers really author agents?
Yes — that is the point. Once the module is installed, operations users create and edit agents in a standard Odoo backend form: name, model, system prompt, response style, and bindings, with no Python and no server restart per agent. Developers are only needed for the initial build and for new integration surfaces beyond what we deliver.
Related Modules

CRM Duplicate Prevention & Deduplication
Real-time duplicate warnings and fuzzy multi-field matching for Odoo leads & contacts, plus a bulk dedup & merge wizard. Built to order.

CRM Stage History & Pipeline Aging
A build-to-order Odoo module that records every stage transition on your opportunities, measures how long deals sit in each stage, and surfaces stuck and aging pipeline so sales managers can act before deals go cold. ECOSIRE builds, installs, and supports it after you request a quotation.

Customer Credit Limit With Approval
A build-to-order Odoo module that enforces per-customer credit limits on sales orders and routes over-limit deals through a multi-level approval chain before confirmation. ECOSIRE scopes, builds, installs, and supports it for your Odoo 17/18/19.

Customer Loan Management
A build-to-order Odoo module that manages the full customer loan lifecycle — origination, approval, amortization schedules, repayments and reconciliation. ECOSIRE designs, builds, installs and supports it to your exact lending rules.
Custom AI Agent Builder
A no-code configuration layer for Odoo that lets your team define, deploy, and monitor custom AI agents — pick the model, write the behavior, bind it to real records — without touching Python. Built to order, installed, and supported by ECOSIRE.
- New `ecosire.ai.agent` model with a no-code backend form (OWL/XML) to author agents — name, model, prompt, and bindings — with zero Python and no server restart per agent
- Provider/model `selection` field spanning OpenAI GPT, Google Gemini, and Anthropic Claude, so each agent picks the right engine for its task and cost profile
- Per-agent system prompt, response-style, temperature, and max-token controls stored as fields on the agent record — version-tracked via chatter
- Model/record bindings via Many2one and Many2many so an agent is scoped to specific Odoo models (e.g. `sale.order`, `helpdesk.ticket`, `account.move`) and only reads their fields