The AI-native ERP operating system.
Intelligence is the layer, not the sidebar.
Not a chatbot bolted onto a ledger. Eleven reasoning engines, eleven shared platform services and a governed agentic runtime — native to every ERP object, permission and workflow you already run. Cobalt ERP works out what needs a person, prepares the work, and hands it over for confirmation.
One core. Every module. No parallel stacks.
Most vendors ship an AI feature per module and call it a platform. Cobalt ERP is built the other way round: a single Intelligence Core, three axes, and every domain plugging into the same contracts, the same evidence spine and the same governance.
Reasoning engines
How the system reasons — deterministic policy, data mining, machine learning, process mining, optimisation, simulation, knowledge graph, retrieval, document, language and causal decision.
Platform services
How intelligence runs safely — contracts, capability catalogue, context, the data plane, composition, execution, registries, evaluation, evidence, control and experience.
Business capabilities
Every applicable ERP capability across Finance, quote to cash, procure to pay, warehouse management, Manufacturing, Service, HR and platform administration — each using only the engines that materially improve it.
Intelligence operates on native ERP objects and workflows, under the same permissions and approvals, inside the record you are already looking at — and it measures the actual outcome after you act.
The definition of AI-native, as Cobalt ERP builds itEleven reasoning engines.
Each engine answers a different kind of question, and each carries a hard boundary it will not cross. A capability uses only the engines that materially improve it — Cobalt ERP does not force a language model into a screen that needs arithmetic.
Accounting arithmetic, tax rules, validation, eligibility, hard constraints, reason-coded checks and deterministic what-if.
The ledger's own maths. Never a model's opinion.
Cohorts, associations, sequences, clusters, outliers, change points and data-quality patterns.
Association is never represented as causation.
Classification, regression, survival and duration models, demand forecasts, calibrated probabilities and intervals.
Advisory derived data — never permission, ledger or approval authority.
Object-centric process discovery, conformance, variants, bottlenecks, waiting time, rework and control-bypass evidence.
Shows you the process you actually run, not the one on the diagram.
Constraint solving, scheduling, bounded heuristics and multi-objective selection across routes, waves, loads and plans.
Distinguishes feasible, best-known and proven optimal. No silent relaxation.
Deterministic scenarios, Monte Carlo, discrete-event simulation, sensitivity analysis and bounded digital twins.
A scenario is not a forecast, a commitment or an authorisation.
Typed relationships, ontology, dependency traversal, graph context, lineage and candidate pruning.
Context for the ledger — never a shadow copy of it.
Permission-aware lexical, vector, graph-assisted and prior-case retrieval, with cited policies and procedures.
Authorisation happens before retrieval, never after.
text recognition, layout, tables, classification, extraction, and barcode, image and signature evidence.
Extracted values stay candidates until validated or accepted.
Intent routing, clarification, summarisation, natural-language query, typed-tool orchestration and grounded explanation.
Explains the verdict. Never produces one.
Safe-candidate ranking, objective arbitration, uplift modelling, experimentation and causal analysis.
A score is not permission. Causal claims require a defensible design.
The unified proposal and action lifecycle every engine hands work to — staged, approved, executed and receipted.
The only door between thinking and doing.
Eleven services that make it safe to run.
Reasoning is the easy half. The hard half is contracts, context, provenance, cost and control — and it is the half most teams skip. Every engine above runs on all eleven of these.
Versioned artifact schemas, common headers, compatibility and validation, so nothing emits a shape nobody agreed to.
Capability manifests, domain registration, dependency and reachability checks. Advertised always equals executable.
Tenant, actor, legal entity, book, jurisdiction, currency, site, warehouse, period, policy and permission scope.
Point-in-time facts, object-centric events, feature definitions, frozen datasets and data-quality gates.
Typed recipe execution, parallel branches, joins, arbitration, fallback and — crucially — abstention.
The job ledger, scheduled and triggered work, batch scoring and bounded interactive execution.
Models, datasets, process models, ontologies, playbooks, prompts, indexes and manifests — all versioned.
Outcomes, intervention exposure, metrics, drift, promotion, demotion and retirement.
Sources, lineage, citations, calculation receipts, limitations and replay evidence.
Isolation, the provider gateway, risk, the action lifecycle, separation of duties, consent and kill switches.
Panels, queues, the assistant, feedback, alerts, cost, retention and the operational control centre.
The cheapest layer that clears the bar.
Every request — a typed question, a dropped invoice, an agent's next step — walks the same cascade and stops at the first layer that resolves it confidently. Which is why Cobalt Intelligence is fast, cheap, and does not fall over when a provider does.
Use the cheapest execution layer that meets a defined quality, safety and latency threshold.
The governing principle of the Intelligence CoreAgents that coordinate goals — not a chatbot with database access.
Cobalt ERP's agentic plane runs durable, multi-day work: it plans against registered skills, executes through your real domain services, and independently verifies that the outcome actually happened. Autonomy is granted per action and per workspace, never as a blanket switch.
Selects from registered skills and builds a bounded plan. It cannot reach a tool directly — everything goes through the runtime.
Invokes registered operations under live policy, re-resolving permission and context at every step, and records typed results.
Independently asks the task's authoritative success question. Deterministic wherever possible — and separate from whoever did the work.
Enforces step, time, cost and fan-out limits, cancellation, kill state, stale context and scope growth.
Agents coordinate goals. Skills provide reusable procedures. Intelligence produces evidence. Domain services decide and write. Humans retain consequential authority.
The agentic contractThe loop, every time
Resolve live context and the acting user before anything runs.
Only capabilities this workspace and this person may actually use.
Preflight every node before a single one executes.
Gather evidence, checkpoint typed results, clarify when unsure.
Anything consequential becomes a governed proposal, not an action.
A human approves, or an explicitly admitted automation policy applies.
Permission and fingerprint re-checked, then your domain service performs it.
The success contract is tested independently, and a receipt is emitted.
The autonomy ladder
Eight rungs, admitted one action and one workspace at a time. Most work lives in the middle. The top rung is a decision you make deliberately, per action, with caps and a kill switch.
Seventeen Domain Intelligence Packs.
Every ERP module gets its own pack — the layer that knows what a warehouse, a supplier or a period actually is. The core never branches on which domain is calling; adding one is a manifest file, not a rewrite.
WORKWork queue
master data managementMaster data
customer relationshipsCustomer relationships
quote to cashQuote to cash
SUBSubscriptions
procure to payProcure to pay
INVInventory
warehouse managementWarehouse
DISTDistribution
MFGManufacturing
FSVCField service
SDService desk
HRPeople
FINFinance
FAFixed assets
PLATPlatform
PROJProjects
What that looks like in your day
Quote to cash
Sell without surprises
- Conversion probability on every quote
- Margin-leakage and discount analysis
- Promise confidence with fulfilment alternatives
- Return root-cause clustering
- Order blockers diagnosed before dispatch
Finance
Close faster, defend every number
- Invoice capture, coding and three-way match
- Duplicate and payment-risk review
- Bank reconciliation and cash application
- Continuous close with period-over-period memory
- Expected collections and cash at the 50th and 90th percentile
Inventory & warehouse
Stock that plans itself
- Demand forecasting by pattern class
- Dynamic safety stock, reorder point and quantity
- Slow, dead and obsolescence detection
- Wave, pick and cycle-count prioritisation
- Short-pick and stockout risk before the shift starts
Procure to pay
Buy on evidence
- Learned supplier lead time at the 50th, 80th and 90th percentile
- Sourcing comparison and contract leakage
- Purchase-order consolidation opportunities
- Expedite versus stockout trade-off
- Supplier bank-change monitoring
Distribution
Every van, every drop
- Vehicle and load planning under real constraints
- arrival-time risk and failed-delivery patterns
- Cost-to-serve per customer and per route
- Carrier selection and dispatch cut-off risk
Onboarding & support
It sets itself up
- Adaptive discovery interview, then a configuration blueprint
- Guided migration with rehearsal and rollback
- Tenant-aware support that knows your exact configuration
- Deterministic diagnosis of why something is blocked
Every claim says where it came from.
Five sources, one taxonomy, applied to every surface in the product. A figure computed from your ledger is never allowed to present itself as something a model wrote — and the reverse is equally true.
Behind each one sits a calculation receipt: the facts that went in, the rule or model version that ran, the evidence it cited, and the limitations it declared. Predictions are recorded before the outcome is known, and compared to what actually happened afterwards — so accuracy is something Cobalt ERP can be held to, not something it asserts.
What makes Cobalt ERP "AI-native" rather than AI-enabled?
Intelligence operates on native ERP objects and workflows, uses the same permissions and approvals as the rest of the system, and appears inside the record you are already working on. There is one core shared by every module — not a separate AI stack per area, and not a chatbot in a corner. It shows evidence, scope and uncertainty, and it measures the actual outcome after you act.
What does "agentic" actually mean here?
An agent takes a goal, plans against registered skills, gathers evidence, prepares the work and carries it to a verified outcome — across days or weeks if that is what the job needs. It runs on a durable runtime, so a task can wait for a person, survive a deployment, resume, and still finish. What it does not do is invent business rules, browse your database freely, or hold authority a person did not grant it.
Can it act on its own?
Up to the rung you admit, per action and per workspace. Most teams live between Prepare and Attended apply — Cobalt ERP does the work, you confirm. Bounded automation is a deliberate opt-in for individual reversible actions, with value caps, a cooldown, a live kill switch and automatic downgrade if quality drifts. There is no blanket autonomy switch anywhere in the product.
Which model does it use?
The Intelligence Core is provider-neutral — Anthropic's Claude and OpenAI's GPT models both run behind one internal gateway, and which one serves a deployment is configuration. Most requests never reach a model at all: they resolve on the deterministic and on-device layers, which is why the system stays fast and cheap.
What happens to my data?
Every external call passes one gateway that records the tenant, capability, purpose, field classifications, consent, residency, redaction plan and cost ceiling. Personal fields are redacted rather than pseudonymised. Nothing is pooled across workspaces — models, indexes, graphs, caches and evaluation results are all tenant-scoped — and nothing trains on your data.
Which plan includes Cobalt Intelligence?
Growth and above, with monthly credit allowances of 100 on Growth, 500 on Scale and 2,000 on Premier. The deterministic layers are free forever and never consume a credit — running out degrades you to them rather than switching anything off.