Invoicing
Should this work have been invoiced?
An intervention finished, a contract still active, an order delivered… and invoicing that never followed. Kohentra tells a normal delay from a genuine miss.
Operational intelligence for Dolibarr
What deserves your attention today?
Kohentra learns how your business really uses Dolibarr, works out what should normally happen next, and shows you only what is worth a look. When a situation calls for it, it brings in a specialised business agent. Every conclusion can be explained and corrected, and each one sharpens the next.
- Read-only by default
- Isolated workspaces
- Every conclusion explained
Already a customer? Log in →
To review today
3 situations
-
Recurring billing Monthly invoice expected, never issued This customer has been invoiced every month for over a year. This month's invoice is missing and the tolerance has passed.
-
Intervention Work done, intervention never closed All its lines ended 12 days ago. The closing threshold set for your business has been exceeded.
-
Ticket Customer ticket with no follow-up No progress beyond the expected follow-up. An agent has already checked it: this is not spam.
Everything else was examined and did not need your attention.
Example situation
Past · Present · Expected future
Kohentra reads the past to understand the present, and to judge what should happen next.
-
Past
Understand what really happened
Your Dolibarr history: the objects you actually use, how they relate, the sequences they follow, their rhythms.
-
Present
See what matters now
Not every gap. Not every missing record. Only the situations that, given how your business actually runs, deserve a human look.
-
Expected future
Judge what should happen next
When the evidence allows, Kohentra establishes what is expected (an invoice, a closure, a follow-up) and checks that it happens.
No crystal ball: an expectation your own data demonstrates, and always explained.
It discovers your business
Kohentra learns your business before it claims to analyse it.
Your Dolibarr is not a textbook model. Enabled modules, custom fields, data-entry habits: every company uses it its own way.
Kohentra doesn't ask you to describe everything up front. It connects to your Dolibarr read-only and discovers how you really work.
- The objects you actually use, not just the ones that exist.
- The data you can rely on, filled in often enough to count as evidence.
- Native relations: third parties, contracts, interventions, invoices, tickets…
- Relations that can be rebuilt, tested against your data before they are used.
- Your add-on modules and the objects they bring, such as an asset management module.
- Your business chains, as they can actually be observed in your company.
It learns what is normal
Then it learns what normal looks like for you.
Billing rhythms, usual lead times, recurrences, sequences, exceptions that keep coming back: Kohentra measures how your business really behaves, on your own history, not on a generic rule.
And when it doesn't know enough, it holds back. And tells you so.
- History
- Recurrences
- Usual lead times
- Business sequences
- Repeated relations
- Expected events
- Recurring exceptions
Missing data is never, by itself, an anomaly.
The expected future
What should happen. What did happen. What deserves your attention.
- Given this activity, what should normally happen next?
- Did it actually happen?
- If not, does that absence really deserve your attention?
- This customer is invoiced every month
- Next invoice expected, with a measured tolerance
- No invoice within the expected window
- Situation to review
- Work done: every line is in the past
- Administrative closure expected
- Deadline passed, nothing has moved
- Situation to review
- Ticket opened
- Follow-up normally expected
- No progress past the usual delay
- Kohentra checks whether that is really unusual
Kohentra doesn't predict the future. It extends a rhythm it has measured, with a tolerance drawn from how regular that rhythm is, and refuses to project when the basis is too thin. A new projection can first run in observation, bothering no one, until it has shown it gets things right.
A short queue, not an alert feed
12,000 anomalies are worthless if nobody knows which ones to look at.
Kohentra isn't trying to detect as much as possible. It looks for the fewest situations that truly deserve your attention, and tells you why each one is there.
What your tools give you
- Yet another dashboard
- Rigid rules, written once and for all
- Scores nobody can explain
- Hundreds of anomalies to sort through
- Notifications nobody reads any more
What Kohentra gives you
- A short queue: “To review”
- Every situation with the facts behind it
- A missing event flagged only if it was expected
- What you've settled stays settled, unless the facts change
- An explicit “not enough evidence” instead of a guess
Why the queue can stay short
- Discovery of how you work
- Your history
- Relations between your objects
- Expected events
- The context of each situation
- Memory of what was already handled
- Your decisions
- Specialised agents
Business agents
Specialised agents, called in when their expertise really counts.
Invoicing, closing an intervention, qualifying a ticket, matching related records: some situations need precise expertise. Kohentra knows which one, when, and within what scope.
- Detectthe situation in your activity.
- Gather the contexthistory, linked objects, conclusions already known.
- Decide whether expertise helpsand launch nothing when it doesn't.
- Pick the right capabilityand open up only the scope it needs.
- Collect its conclusionwith the facts that support it, and keep it.
- Never redo what is solvedand test every conclusion against reality.
Not an army of autonomous agents.
A lone agent is not Kohentra. Kohentra is the layer that decides which agent looks at what, remembers what it concluded, and measures what its conclusions are worth.
Agent designer
Your business expertise becomes a Kohentra capability. No custom development.
Describe what you want an agent to do, the way you would explain it to a colleague. The designer helps you turn it into a complete definition that you review and approve: its domain, the situations it examines, its criteria, the context it may read, how it reasons, its possible conclusions and what each one means, and the actions it may propose.
Every agent is versioned. Every version declares what it reads and what it may request. Nothing is granted when it is created.
- Flexibility
- Specialisation
- Versioning
- Governance
What do you want this agent to do?
« Spot the services we keep buying even though no active customer contract seems to cover them any more. »
- It examines
- Service purchase lines
- Context
- Active customer contracts
- It concludes
- Covered · Ambiguous · Not covered
- Reasoning
- Rules first, then a bounded language model
- Actions
- Propose only
New agent: version 1.0.0, in observation, with no authority at all.
Qualification
An agent has to prove itself.
At Kohentra, improving an agent doesn't mean blindly swapping out the old one. A new version first works alongside the one in service, on the same situations, with no business effect. You compare. You judge. It goes live only when you decide.
- DesignDefine the expertise in the designer.
- ObserveIt concludes on your real data, with no authority.
- QualifyYour judgements measure what its conclusions are worth.
- PrepareA new version, starting from zero.
- Evaluate side by sideSame situations, same input, no effect.
- CompareAgreements, disagreements, cases already settled.
- Promote, keep measuringOn your decision. Measurement never stops.
Agent · Ticket classification
| Version | Status | In your workspace |
|---|---|---|
| 1.0.0 | In service | Qualified on your judgements |
| 1.1.0 | Under evaluation | Same tickets, no effect · disagreements to judge |
| 1.2.0 | Prepared | Not published: runs nowhere |
A published version never changes. None inherits the trust earned by the previous one.
A new version isn't better because someone changed it. It has to prove it.
Humans at the heart of the loop
Your decisions don't just close an analysis. They teach Kohentra to judge the next one better.
For every agent conclusion, you say whether it is correct, incorrect (and which conclusion was expected) or impossible to judge. It isn't a courtesy click: it's the only evidence Kohentra accepts.
Your judgements tell it:
- what was right, wrong or ambiguous;
- what is normal in your business;
- where an agent cries wolf, misses things or plays it too safe;
- whether a new version really beats the previous one.
- Kohentra proposes
- You confirm or correct
- Kohentra measures
- The agent or the understanding improves
- The new version is evaluated
- … and the loop starts again
Governed learning
Kohentra learns continuously. It never quietly changes the rules of the game.
Learning is continuous. Trust has to be demonstrated.
-
Automatic discovery
Objects, domains, usage, relations.
-
Behavioural learning
Habits, lead times, recurrences, business chains, expected events.
-
Human learning
Conclusions confirmed, corrected or rejected.
-
Agent improvement
Measured weaknesses drive a new version.
-
Qualifying the improvement
Every new version is tested against reality before it serves.
What Kohentra is not
- A score nobody can explain
- A language model that decides everything
- Behaviour that changes without warning
- A memory that forgets your decisions
- The same analysis rerun for nothing
- Missing data treated as a mistake
- Autonomy handed to an agent by default
What Kohentra is
- Explainable
- Traceable
- Versioned
- Measurable
- Reversible
- Qualifiable
You stay in control of trust, and of autonomy.
Kohentra is read-only by default. Today, most of what it concludes still goes to a human decision.
But trust can be earned. For each action, you choose the level of autonomy: propose only, execute after confirmation, or execute without prior confirmation once the evidence is there. Action by action, always supervised, always logged, always revocable.
Use cases
Real questions. Not technical concepts.
What Kohentra handles, phrased the way you would ask it.
Interventions
Can this intervention really be closed?
Close too early and you lose a follow-up still due. Close too late and it buries the ones that matter. Kohentra tells you when every condition is met.
Expected events
Did an expected step fail to happen?
Your tools see what happened. Kohentra also sees what should have happened, and didn’t.
Support
Why does this ticket deserve my attention?
Between spam, requests already dealt with and real customers left waiting, Kohentra sorts things out, and tells you why a ticket stands out.
Relations
Does this business relationship hold together?
Customer, contract, intervention, equipment: Kohentra measures what really links your records, and never passes off a correlation as a certainty.
Add-on modules
Does Kohentra understand the modules specific to our Dolibarr?
Asset management, connectors, in-house modules: Kohentra discovers the objects your add-ons bring and links them to the rest of your business, without custom code.
Security and control
A capability only reaches what it needs.
Kohentra reads your activity to help you decide. It never grants itself the right to act, and every agent stays within the scope it has declared.
-
Isolated workspaces
Each company has its own data, settings and users. None can see another's.
-
Read-only by default
Nothing is written to your Dolibarr without explicit permission, action by action.
-
Declared scope
Each agent version declares what it reads, what it may pass to a language model and what it may request. Everything else is refused.
-
Secrets out of reach
No agent can read an API key, a login or a token.
-
Everything is logged
Conclusions, judgements, activations, permissions: who, when, on which version.
-
Everything is reversible
Roll back to an earlier version, withdraw a permission, put an agent back into observation: always possible.
Straight answers
What people ask us first
Is this just ChatGPT plugged into Dolibarr?
No. Kohentra has a business memory, a model of how your objects relate, expected events, orchestration, qualified and versioned agents, and human review loops. Its core analyses are deterministic. When an agent does call a language model, the model sees only what the agent is allowed to send it, and it never gets write access.
Is it just another alerting engine?
Quite the opposite. Its whole purpose is to cut the noise: show you only what deserves your attention, with the facts that justify it.
Does Kohentra claim to predict the future?
No. It establishes what should normally happen based on behaviour and relations demonstrated in your data, and it holds back when it doesn't know enough.
Can I trust the agents blindly?
No, and that's by design. An agent starts in observation, with no authority. It is qualified on your judgements, and every new version is evaluated and compared before it goes live.
What happens to my feedback?
It measures the quality of conclusions, exposes an agent's mistakes and drives its next versions. It never rewrites history, nor your Dolibarr.
Do I have to configure everything first?
No. Kohentra first discovers your objects, relations and usage. You stay in control of what it is allowed to read.
Does Kohentra work with anything other than Dolibarr?
Kohentra works with Dolibarr today, and that is where it has proven itself. We don't claim to be a universal platform.
What if your Dolibarr finally told you what matters?
See the situations Kohentra brings to the surface, and how it backs each one up.
Already a customer? Log in →