Skip to main content
AI Agents Framework (CrewAI DocTypes) — A build-to-order ERPNext app that models AI agents, tools, and tasks as native DocTyp — 1/1Illustrative preview

A build-to-order ERPNext app that models AI agents, tools,

and tasks as native DocTypes and runs them with CrewAI to automate multi-step workflows.

ECOSIRE scopes, builds, installs, and supports it — this is not an instant download.

What is AI Agents Framework (CrewAI DocTypes)?

A build-to-order ERPNext app that models AI agents, tools, and tasks as native DocTypes and runs them with CrewAI to automate multi-step workflows. ECOSIRE scopes, builds, installs, and supports it — this is not an instant download. Built to order by ECOSIRE for ERPNext v15, v16 — indicative price from $999.00 USD; request a quote for a scoped proposal.

Key Features

`AI Agent`, `AI Tool`, `AI Task`, and `AI Crew` modelled as native Frappe DocTypes with list views, permissions, and version history
CrewAI-based multi-agent orchestration — sequential and hierarchical crews where a manager agent delegates to specialist agents
Tools are whitelisted, permission-checked wrappers over the Frappe REST API and bench methods (`frappe.get_doc`, `frappe.get_list`, `frappe.new_doc`)
Agent runs execute in the background worker queue via `frappe.enqueue`, so long LLM calls never block the web request
Trigger agents from `hooks.py` doc events (`after_insert`, `on_submit`, `on_update`) through a thin, idempotent dispatcher
Scheduler-event triggers (hourly/daily/weekly/cron) for batch and monitoring agents
On-demand execution from a client script form button or a whitelisted method
Human-approval checkpoints: agent pauses, creates an approval record routed by role profile, and resumes only after sign-off
Per-agent tool allowlist and role/permission scoping so an agent can never exceed the access you grant it
`AI Agent Run` log capturing full step trace, tool calls, inputs/outputs, token usage, and final status for auditability
Encrypted LLM provider settings (API keys in Site Config / a Settings DocType, never in source or DocType data)
Per-agent model selection and configurable temperature, max-iterations, and timeout guardrails
Structured output parsing so agent results map back onto ERPNext fields, child tables, or new documents
Retry, error-capture, and rate-limit handling on failed steps with the failure surfaced in the run log
Built for Frappe/ERPNext v15 and v16, packaged as an installable Frappe app with fixtures for the DocTypes and role profiles

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your ERPNext.

  3. 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

ERPNext Compatibility
—
License
Licence confirmation required
Python Requirement
Python 3.10+
Database
MariaDB 10.6+

About this Product

ERPNext gives your team a solid rules engine — server scripts, workflow states, notifications, and scheduler events — but all of it is deterministic. The moment a process needs judgement (read this email, decide which supplier to chase, draft a reply, reconcile a fuzzy match, summarize a long thread and route it), your team drops back to manual work or bolts on brittle glue code that lives outside ERPNext and nobody can maintain. Native ERPNext runs out of road exactly where multi-step, reason-then-act automation begins, and that is the gap this framework closes.

We build a proper Frappe app that introduces AI Agent, AI Tool, AI Task, and AI Crew DocTypes so your autonomous agents become first-class ERPNext records — versioned, permission-controlled, list-viewable, and audited like any other document. Under the hood the app orchestrates these definitions with CrewAI: each AI Agent carries a role, goal, backstory, and an allowlist of AI Tool records; each tool is a whitelisted, permission-checked wrapper over the Frappe REST API or a bench method so an agent can read a Sales Order, create a ToDo, post a Comment, or call frappe.get_doc/frappe.get_list — but only within the roles you grant it. Agents run inside the background worker queue, so long-running LLM calls never block the request. Every run writes an AI Agent Run log with the full step-by-step trace, token usage, and the tool calls it made, so you can see exactly what the agent did and why.

Agents are triggered the way you already trigger automation in ERPNext: from hooks.py document events (on_submit, after_insert, on_update) via a thin dispatcher, from scheduler events (hourly/daily/cron) for batch runs, or on demand from a client script button on the form. Where a step has real-world consequences — sending a payment, emailing a customer, submitting a document — the framework inserts a human-approval checkpoint: the agent pauses, creates an approval record routed to the right role profile, and only resumes once a person approves in ERPNext. LLM provider keys live in a Site Config / encrypted settings DocType, never in code, and you choose the model per agent.

Because this is build-to-order, nothing ships as a generic download. We start with a short scoping call, map your target workflows to concrete agents/tools/tasks, and agree the approval gates and permission boundaries. We then build your version of the app, test it on a staging bench, run UAT with you, and install it on your Frappe/ERPNext v15 or v16 site. You receive the full source and git repo, documentation, and training — and a post-go-live support window so the agents behave as scoped in production.

What you get

  • Installable source code for your version of the app (full Frappe app, no obfuscation)
  • Installation and configuration on your ERPNext v15/v16 site, including LLM provider wiring and role profiles
  • Technical documentation: DocType schemas, tool contracts, hooks/scheduler wiring, and how to add a new agent or tool
  • User guide plus a live training session for your admins and process owners
  • Post-go-live support window for defect fixes and agent-behavior tuning as scoped
  • UAT on a staging bench with a documented rollback plan before production install
  • Git repository handover with commit history and branching notes
  • Configured seed agents/tools/tasks for the specific workflows agreed during scoping

Who this is for

ERPNext admin / in-house Frappe developer

Owns the site and wants AI automation that lives inside ERPNext as DocTypes they can read, permission, and extend — not an external black-box service they cannot maintain or audit.

Operations / back-office lead

Drowning in repetitive multi-step tasks (triage, reconciliation, drafting, chasing) and wants agents to handle the routine steps while a human still approves anything with financial or customer impact.

CTO / systems integrator

Standardizing AI across several ERPNext processes and needs a governed framework with permission boundaries, run logs, and human-in-the-loop gates rather than scattered one-off scripts.

Finance / procurement manager

Wants agents to prepare and route documents (bill matching, supplier follow-ups, approval drafts) but requires an explicit sign-off checkpoint before anything is submitted or sent.

How AI Agents Framework (CrewAI DocTypes) Compares

CriterionECOSIRECustom BuildCompetitorERPNext Native
Runs inside ERPNextAgents/tools/tasks are native DocTypes on your benchDepends on your build; often lives outside ERPNextFrequently an external SaaS bridge, not native recordsNo agent concept at all
Multi-agent orchestrationCrewAI sequential and hierarchical crewsYou build orchestration from scratchUsually single-prompt automations onlyNone
Human-approval checkpointsBuilt-in pause/approve routed by role profileMust be designed and coded yourselfRarely offered or shallowManual workflow states only, not AI-aware
Permission-scoped tool accessWhitelisted, role-checked wrappers over Frappe APIsOnly as strong as your own guardrailsOften broad API tokens with weak scopingN/A
Auditability`AI Agent Run` log with full step trace + token usageWhatever logging you remember to addLimited or vendor-side logsN/A
TriggersDoc events, scheduler, and on-demand buttonHand-wired per use caseUsually webhook or schedule onlyServer scripts/notifications, no AI reasoning
Source ownershipFull source + git repo handoverYou own it, but you also carry all the build riskClosed source / subscription lock-inCore app, not customizable to this
Time to running solutionone working week build-to-order, scoped and supportedMonths of in-house design and iterationFast to install but generic and shallowNot achievable without development

Frequently Asked Questions about AI Agents Framework

How long does delivery take?

This is a build-to-order app, so there is no instant download. Typical delivery is one working week from confirmed scope, depending on how many agents and tools you need and the complexity of the approval gates. We agree the timeline in writing after the scoping call.

How do you handle support and updates after go-live?

Every engagement includes a post-go-live support window for defect fixes and agent-behavior tuning as scoped. Beyond that we offer ongoing support and enhancement retainers. You also receive the full source and git repo, so your own team can maintain and extend the app if you prefer.

Which ERPNext versions are supported?

We build and test against Frappe/ERPNext v15 and v16. Tell us your exact bench version during scoping and we target that; we install and run UAT on a staging copy of your site before touching production.

Can agents act on my ERP data without a human approving?

You decide. Agents can run read-only or low-risk steps automatically, but any step with real consequences — submitting a document, sending money, emailing a customer — passes through a human-approval checkpoint routed to the role profile you choose. The agent pauses until a person approves inside ERPNext.

Where do the LLM API keys live, and which provider do you use?

Provider keys are stored in encrypted Site Config / a Settings DocType, never in source or DocType data. You choose the model per agent (for example an OpenAI, Anthropic, or self-hosted model) and supply your own provider account, so token usage stays on your billing.

How are agents triggered?

Three ways, all native to Frappe: from document events in `hooks.py` (such as `on_submit` or `after_insert`), from scheduler events on an hourly/daily/cron cadence, or on demand from a form button. A thin dispatcher enqueues the run in the background worker so nothing blocks the UI.

Do we own the code?

Yes. You receive the complete installable source and a git repository handover with commit history. There is no per-seat lock-in on the app itself; you are free to run, modify, and extend your version.

Request a quote

AI Agents Framework

A build-to-order ERPNext app that models AI agents, tools, and tasks as native DocTypes and runs them with CrewAI to automate multi-step workflows. ECOSIRE scopes, builds, installs, and supports it — this is not an instant download.

  • `AI Agent`, `AI Tool`, `AI Task`, and `AI Crew` modelled as native Frappe DocTypes with list views, permissions, and version history
  • CrewAI-based multi-agent orchestration — sequential and hierarchical crews where a manager agent delegates to specialist agents
  • Tools are whitelisted, permission-checked wrappers over the Frappe REST API and bench methods (`frappe.get_doc`, `frappe.get_list`, `frappe.new_doc`)
  • Agent runs execute in the background worker queue via `frappe.enqueue`, so long LLM calls never block the web request

Request a Quotation

Tell us about your AI Agents Framework requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.