Product details are displayed in English. Translations coming soon.
Quick facts
- Price
- $499.00 USD
- Odoo versions
- 17, 18, 19
- Setup time
- 30 min
- License
- One-time perpetual
- Languages
- 11 languages
एक बार की खरीदारी
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.
$499.00USD
अभी कोई भुगतान नहीं। यह हमारी टीम को एक कोटेशन अनुरोध भेजता है — हम कीमत और अगले चरणों के साथ ईमेल द्वारा संपर्क करेंगे।
प्रमुख सुविधाएँ
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
Invocation from a smart button, an `ir.actions.server` automated action, or the external JSON-RPC/XML-RPC API — same agent, multiple trigger surfaces
Automatic prompt marshalling: bound record fields are serialized into the prompt template and the response is written back to a field, chatter, or `mail.activity`
`ir.model.access.csv` + `ir.rule` record rules ensure agents respect the invoking user's existing ACLs — no privilege escalation around Odoo security
Encrypted API-key storage via `ir.config_parameter` (never plaintext in views or logs), with outbound calls gated to the agent's declared binding
Usage and cost monitoring: token-counter fields plus a `compute`d cost field (`@api.depends`) and a per-agent run log model for spend visibility
Optional per-run audit report rendered with QWeb, capturing prompt, model, tokens, and the record it acted on
Configurable retry/timeout and graceful failure handling so a provider outage logs an activity instead of breaking the business flow
Multi-company aware — agents and logs carry `company_id` and respect company record rules in multi-company databases
Compatible with Odoo 17.0, 18.0, and 19.0 (Community and Enterprise) — the target version is pinned in `__manifest__.py` at build time
Rate-limit and daily-spend guardrails per agent so a runaway automated action cannot exhaust your provider budget
इस उत्पाद के बारे में
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.
Custom AI Agent Builder (No-Code) क्यों चुनें
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
Invocation from a smart button, an `ir.actions.server` automated action, or the external JSON-RPC/XML-RPC API — same agent, multiple trigger surfaces
Automatic prompt marshalling: bound record fields are serialized into the prompt template and the response is written back to a field, chatter, or `mail.activity`
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 2–4 weeks 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.
Installation overview
Download from ECOSIRE
Buy the license on ecosire.com and download the Custom AI Agent Builder (No-Code) module ZIP from your account dashboard.
Upload to Odoo
Extract the ZIP into your Odoo custom addons folder on the server (or upload via Apps > Install from file on Odoo.sh / runbot).
Install the module
Activate Developer Mode, open Apps, click Update Apps List, search for Custom AI Agent Builder (No-Code), and press Install.
Configure settings
Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.
Verify & go live
Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.
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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
| Source & ownership | Full source + git repo handover, no lock-in | You own it but also own all the risk | Licensed binary/obfuscated, vendor-dependent | |
| 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 |
Frequently Asked Questions about Custom AI Agent Builder (No-Code)
+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 2–4 weeks 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
कोटेशन का अनुरोध करें
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.
- 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