Search across your documents
Ask a question in plain language, get the passage and the file it came from. No more hunting through shared drives.
Country and language
Other markets: these available language versions show the same page.
Artificial intelligence
One use case at a time, built on your documents and measured against real work. Developed in Paris, connected to the tools your teams already use.
The problem
Most AI projects fail in the same way: a general assistant is bought for everyone, it knows nothing about the company, and three months later nobody opens it. The useful version is narrower. One task that people actually repeat, done on your own documents, with an answer you can check against a source rather than trust on faith.
We start by picking that task with you, and by writing down how we will know it works: time saved per file, error rate, share of answers with a citation. Then we build the smallest thing that does it, connected to your own content — procedures, contracts, tickets, invoices, product data — and we measure it on real cases before anyone deploys it to a whole team.
The technical choices follow the task. Sometimes a hosted model is right; sometimes an open-source model running on a server you control is better, because the documents cannot leave. Where the data is stored, who can query it and what is logged are decided during scoping, in writing, along with the cases the system must refuse to answer.
Use cases
Each one ships on its own. You judge the first before deciding on the second.
Ask a question in plain language, get the passage and the file it came from. No more hunting through shared drives.
Invoices, delivery notes, contracts and forms turned into structured fields your software can read, with a human check on anything uncertain.
Support, sales or back office assistants that answer from your procedures and hand over to a person when they should.
Results land in your CRM, ERP or ticketing system through an API, instead of in a chat window someone has to copy from.
Hosted or self-hosted, in Europe or on your own server. Retention, access and logging agreed before the build starts.
A test set from your real cases, a score before and after each change, and a log of every answer for review.
How we work
Four stages, in this order. You sign off each one before the next starts.
We look for a repeated task with a measurable outcome, and we say plainly when a plain script would do the job better.
1 weekA working version on a sample of your real documents, scored against a test set your team helps build.
2 to 4 weeksThe interface, the connections to your systems, the permissions, the logging and the fallback when the model is unsure.
4 to 8 weeksGradual rollout, training, then monthly review of the logs and the score. Models change; the tests catch it.
OngoingExamples
Not a menu to choose from, but a sense of the size of a first project:
Example project
Procedures lived in eight hundred documents across three shared drives, and new staff asked a colleague rather than search. We built an assistant that answers from those files and shows the source paragraph, with the drive as the single place anything is updated.
Budget
We price one use case at a time. The figure depends on your data and on the integrations.
Indicative figure for a standard scope. Every quote is issued as a fixed price after the scoping phase, with no per-seat fee.
How it is priced
An assistant, an automation or a document pipeline has no list price: it depends on your data, the tools to connect and how much control you need over the answers. We scope, then we price.
We do not put a figure on accuracy, time saved or return on investment before we have seen your data. Whatever can be measured is measured during scoping.
Once it is running
Integrations change, the way people use it shifts, answers drift. The follow-up is priced with the project.
FAQ
A model can, which is why we build so that answers come from your documents and arrive with the source passage attached. The system is set to say it does not know rather than guess, and every answer is logged so you can review what it actually said and correct the content behind it.
That is your decision, taken at scoping and written into the specification. We can run an open-source model on a server you control, so nothing leaves, or use a hosted model in Europe when that is acceptable to you. Retention, access rights and logging are agreed before any build starts.
We build a test set from your real cases before writing anything, and we score against it after every change. You see the same numbers we do: accuracy, share of answers with a citation, and time on a task. If the score does not move, we say so instead of shipping.
Size matters less than repetition. If a task is done fifty times a week on documents you already own, a narrow use case pays for itself quickly. If it happens twice a month, it usually does not, and we would rather tell you that in the first call than sell you a pilot.
See also
Let's talk
Thirty minutes is enough to say whether it is a good first AI use case, and to give you an honest range.