The problem we solve
Generic language tooling struggles with Arabic for linguistic reasons, not cosmetic ones. Dialect differs from formal Arabic in both vocabulary and structure. Real messages mix Arabic and English inside a single sentence. Hamza forms, taa marbuta and alef maqsura mean the same word appears in several written shapes. Local names of people, places and organisations are thin in general-purpose vocabularies. The result is a model that fails precisely on the cases that matter, the team stops trusting it, and everyone quietly returns to reading by hand. We build against your own text and measure on your own examples before anything goes live.
Expected outcomes
- Requests reaching the right team on arrival instead of via manual triage.
- Less time spent reading documents to find a clause, a date or an amount.
- A measurable read on what customers are actually saying, not a team impression.
- Internal search that returns the right document even when the searcher uses different wording.
- Faster handling of urgent cases because they are flagged at intake, not hours later.
- A text archive that becomes queryable rather than sitting as static files.
Who this is for
- Support and service teams handling high volumes of free-text messages.
- Legal and contracting functions reviewing structurally similar documents repeatedly.
- Organisations sitting on large text archives that keyword search cannot unlock.
- Product and marketing teams wanting structured insight from customer feedback.
- Public-facing bodies processing open-format submissions across multiple dialects.
Use cases
- Classifying inbound tickets by type and urgency and routing them automatically.
- Extracting parties, terms and financial obligations from contracts into structured fields.
- Tracking tone in complaints and reviews and clustering the recurring themes.
- Summarising long support threads into a brief a manager can read at a glance.
- Meaning-based internal search across policies, manuals and regulations.
- Entity extraction from field reports: sites, organisations, equipment references.
Deliverables
- A running text-processing service your systems call through a documented API.
- A labelled evaluation set that stays yours and can benchmark any future model.
- A performance report showing where the system is strong, where it fails, and why.
- A human review interface for uncertain cases, with corrections captured.
- A documented annotation guide your team can extend later.
- A monitoring dashboard covering volume, review rates and shifting patterns.
- Source code and instructions for retraining as new data accumulates.
Project phases
Task definition
Fixing the required output, the decision it serves, the category boundaries, and what an error costs in your context.
Sampling and labelling
Collecting varied real text, writing the annotation guide, and building a reviewed evaluation set.
Modelling and trials
Testing several approaches against the same set and comparing them on cost, latency and privacy requirements.
Evaluation and tuning
Measuring performance on the categories that matter most, then setting thresholds and the review route.
Integration and launch
Wiring the service into your systems and running it alongside the current process before full reliance.
Monitoring and improvement
Tracking live performance and feeding team corrections into later improvement cycles.
- Estimated timeline
- 6 to 12 weeks
- An estimate that depends on scope and how quickly reviews come back — not a contractual commitment in itself.
- Pricing
- After scoping
- Scope depends on how many language tasks are involved, whether labelled data already exists, and whether processing must stay inside your own environment. A scoped proposal follows the task-definition session.
Scope and working details
What is in and out of scope, how we work, and what we need from you.
What is included
- Tight definition of the language task and the operational decision it feeds.
- A representative sample of your real text, difficult cases included.
- An annotation guide that removes ambiguity between categories before any training.
- A labelled evaluation set drawn from your data, used as the reference for performance.
- Arabic-specific preprocessing: character normalisation, mixed-language and dialect handling.
- Approach selection — open-weight models inside your environment or a hosted service — with the trade-offs stated openly.
- Confidence thresholds and a defined route for cases sent to human review.
- Integration into your systems through a documented API, plus a review and correction interface.
- Post-launch monitoring, including drift as language and usage patterns change.
What is not included
- Large-scale manual annotation of an existing archive — scoped and priced separately if needed.
- Speech-to-text and call transcription systems, which are a different engagement.
- Ongoing human translation as an operational service.
- Legal interpretation of contract content — we extract the clauses; the judgement stays with your counsel.
- Responsibility for decisions taken automatically without the agreed human review step.
How we work
The first job is narrowing the task. "Understand our customer messages" cannot be built or measured; "classify each message into these categories and route it" can. Before any code, we assemble an evaluation set from your text, because anything not measured on your own data cannot be judged. We then begin with the simplest approach that could work and escalate only when the evidence demands it — a smaller model running inside your environment is usually cheaper, faster and easier to govern than a heavier one. And there is always a defined path for cases the system is not confident about, rather than letting them through.
What we need from you
- A varied sample of your real text, with an agreed approach to any personal data inside it.
- A subject expert who can settle the correct answer on ambiguous cases.
- A clear description of the operational decision that will rest on the output.
- Technical access to the systems that will consume the output or supply the text.
- Team time to review outputs during the parallel-run period.
Methodology and technology
We choose between open-weight language models running inside your environment and hosted services, and set out the cost, latency and data-location trade-offs before you decide. For repetitive high-volume tasks we tune smaller classification models on your data, since they run faster and cheaper in production; larger models are reserved for work that genuinely needs broader comprehension. Preprocessing covers Arabic character normalisation and mixed-language text. Services are written in Python and exposed through an API, storing results and citing the source passage whenever extraction comes from a document. Performance is measured on an evaluation set built from your data rather than public benchmarks, and monitored after launch for drift.
From our work
Lavin Fashion: a complete commerce system, built from scratch
Store, app, AI shopping assistant, automation and supplier links, for a company our owner is a partner in.
How this connects to the rest of our work
A service rarely works alone. These come before it or alongside it, and these are the solutions it forms part of.
Services that work with it
RAG and Enterprise Knowledge Systems
Ask in plain language, get an answer from your own approved documents with the source attached.
AI Assistants and Conversational AI
A bilingual assistant that answers from your approved sources and hands off to your team with context.
Data Analytics and Predictive Intelligence
One trusted data source, dashboards people use, and forecasts tested on your own history.
Part of these solutions
Frequently asked questions
Will this work on dialect, or only formal Arabic?
That is exactly what has to be tested rather than promised. The evaluation set is built from your text as it actually arrives — dialect, mixed Arabic and English, informal spelling — and performance is measured on it. If a particular pattern comes out weak, we address it with additional examples or a change of approach, and you see the numbers before launch rather than after.
We have no labelled data. Can we still start?
Yes. We usually begin with general language models under carefully written instructions, which is enough to validate feasibility quickly. In parallel we label a modest evaluation set, because that is a necessity rather than a luxury: without it there is no objective way to judge performance. As team corrections accumulate, they become the data for tuning a more specialised model later.
Does our text leave our environment?
It depends on the approach, and the choice is yours. Open-weight models can run entirely inside your infrastructure so no text ever leaves, at a higher running cost. If you prefer a hosted service, we document exactly what is sent and how it is retained, and apply redaction of personal data where practical. Any arrangement sits under your own policies and legal review.
What happens when the model gets an important case wrong?
We design for that from the start. Every output carries a confidence score and anything below the threshold routes to human review. More importantly, thresholds are set according to the cost of being wrong: categories where an error is expensive are treated conservatively, even if that means more review volume. Corrections are stored and feed later improvement.
Will it still work as our customers' language changes?
Language does shift — new products, new terminology, different complaint patterns. That is why we hand over a monitoring dashboard where a rising share of cases sent to review acts as an early drift signal, along with a documented process for re-evaluation and update. Your team can run that, or we continue under a support arrangement.
How is this different from an internal knowledge assistant?
A knowledge assistant answers staff questions from your internal sources. This service treats the text itself as material to be processed — classified, extracted, measured — and often has no chat interface at all, because it runs inside an operational workflow. Many organisations end up wanting both, and we separate the two clearly during task definition.