How We Run a Service Business With AI Agents
We are a service business, and we have been putting AI agents into our own operations. This is the architecture from a high level: what the agents do, what our people keep, and what we learned.
Quark Cyber Systems is a service business. We sell expertise by the project: we win the work, find out what the client needs, deliver it, and bill for it. For some time now we have been putting AI agents into that chain ourselves, one workflow at a time.
This article shows the result from a high level, using our own company as the example: what the agents do, what our people keep, and what we have learned from running it.
The shape of a service business
Almost every service business follows the same chain: an enquiry arrives, requirements are gathered, a proposal is agreed, the work is delivered, and money moves in and out. Very little of the time lost in that chain is lost in the skilled work. It goes on the steps between: rekeying an enquiry, chasing a missing detail, typing a supplier's invoice into the accounts, working out who decided what.
Those in-between steps are where we use agents. One rule applies at every stage: the agent proposes, the ERP records, and a person decides. Our working picture is a flight deck. The automation flies the routine, and the crew stays in command and answers for the flight.

Our chain at a glance: what the agent does, who decides and where it is recorded.
Our own chain, stage by stage
1. The enquiry: an agent on the website
A visitor to quarkcs.com is greeted by an AI agent. It has one job: to route the visitor to the right next step within three messages. It works out what they need, asks once for their name, work email and company, and then takes exactly one of two actions. It either logs a lead in our CRM, or it opens a requirements session for the visitor and emails them the link.
The agent cannot quote a price, promise a date or change a record it did not create. Our sales team is notified of every outcome and takes the conversation from there.
2. Enquiries from other people's agents
More and more buyers will send an AI assistant to do their research. Our site is built for that reader too. Every page has a plain Markdown version, and there is a published interface through which an assistant can fetch the questions of our scope evaluation form and submit the answers on a person's behalf.
Nothing submitted this way reaches our CRM until that person confirms by email. An assistant can fill in the form. Only the person it works for can make the request.
3. Requirements: structured before the first meeting
The requirements sessions are online questionnaires, one for each area of the business: accounting, buying, selling, stock, CRM, projects, quality and assets. The client's team answers at their own pace through a private link, and the answers arrive as structured records against the project.
The first conversation with a consultant then starts from the client's own answers, not from a blank page.
4. Delivery: decisions on the record, agents under direction
During a project, each significant decision goes into a decision ledger: the options considered, the reasoning, the impact and who proposed it. A bot in our team chat sends each person a digest of their open tasks.
Our engineers also work with coding agents. The agent writes and tests the change. An engineer directs the work and decides what is released, through the same version control and deployment process as any other change.
5. Supplier bills: read by AI, posted by a person
When a supplier emails an invoice, an automation workflow reads it with AI and creates the purchase invoice in ERPNext. The supplier is matched on the email address we hold for them, and the tax treatment comes from that supplier's settings in the ERP, not from the model.
The invoice is saved as a draft. Someone in finance reviews it and posts it.
What we keep with people
Scope, price, commitments and the client relationship stay with people. An agent can prepare the ground for each of these, and a person answers for them.
Several small agents, on an open-source stack
We do not run one large assistant that does everything. We run several small agents, and each has one job.
- The website agent routes enquiries.
- The invoice workflow reads supplier bills and drafts the purchase invoice.
- The digest bot reports open tasks to each person in team chat.
- Coding agents write and test changes under an engineer's direction.
They work on open-source software that we can read, host and change: ERPNext and Frappe CRM as the system of record, and n8n for the workflow that reads supplier email. Because the stack is open, an agent's permissions are the ERP's own permissions, and we can inspect what every step did.
The models we choose, and why
No single model does every job well, and the largest one is rarely the right one. We choose the smallest model that passes our test for the task. Where the work touches client or company data, we choose open-weight models. We can host them inside our own boundary, adapt them with our own examples, and keep running them if a vendor changes its prices or terms.
This is the path one piece of work takes, with our current choice at each step.
Open-weight modelHosted modelNo modelSelect a step to see why we chose it.
Work arrives
Voice note or callWhisper large-v3-turbo
Voice notes reach us in several languages, and Whisper covers a broad range of them. The turbo version is fast enough to transcribe a message as it arrives. Because the weights are open, recordings stay inside our own boundary.
Scan or PDFPaddleOCR-VL
Most documents are printed invoices, orders and forms. This specialist model has under one billion parameters, reads layout and tables as well as text, and runs on a small GPU. Handwriting, stamps and poor scans are passed to Qwen3.8-27B, a larger model that reads images.
Website conversationHosted model
The website agent holds short public conversations and has no access to company or client records. It needs dependable conversation and tool use in very few turns, and the volume is low, so a hosted model is the practical choice. It works within the same limits as every other agent: three messages, one action and a spending cap.
Each step hands on to the next
Screen the inputQwen3Guard
Anything that arrives from outside is untrusted, including text hidden inside a document. A small guard model screens what comes in and what goes out, separately from the models that do the work.
Sort and routeGemma 4 E2B or E4B, fine-tuned
Sorting needs speed more than depth. A small fine-tuned model tags each item with its intent, language, urgency and owner, and it runs on a small GPU or a CPU. A large model would be slower and would cost more for no better answer.
Find the contextQwen3-Embedding + Qwen3-Reranker
What a model is shown decides what it can get right. The embedding model finds candidate passages and the reranker puts the best few first. Both come in sizes from 0.6 to 8 billion parameters, so retrieval can be matched to the hardware. Permissions are applied before anything reaches a model.
Fill the recordGemma 4 E4B, fine-tuned
Extraction is high in volume and repetitive, which suits a small model trained on our own approved examples. Its output is constrained to a JSON schema, so it always parses, and the ERP validates every field. Records it is unsure of go to Qwen3.8-27B.
Plan and act with toolsgpt-oss-120b
Planning several steps and calling tools is the hardest job in the chain, and it needs a reasoning model with tool calling. This one has open weights and fits on a single 80 GB GPU, so even the agent that acts in the ERP can run inside our boundary.
The action gateCode
There is no model here, on purpose. Identity, limits, approval rules and duplicate checks are written in code and run before anything is written or sent. A model can be persuaded. A rule in code cannot.
A person decidesNamed owner
Anything that moves money or makes a commitment stops at a draft. The reviewer sees the proposal, the evidence and the rule that applies, then approves, amends or rejects.
The ERP recordsERPNext
The approved action is posted through the ERP's own validation and permissions. The run is stored against the record with its conversation, outcome and cost.
Four rules sit behind these choices.
- Test on our own records. A model is chosen on a test set built from real, recent cases, not on a public leaderboard.
- Try without training first. We test prompting and retrieval on the base model, and fine-tune with small LoRA adapters only when that falls short.
- Keep models replaceable. Our design puts every model behind one gateway with a standard interface, so changing a model is a configuration change and not a rebuild.
- Review regularly. Open-weight models are released every few months. We check each licence and run the comparison again.
The fuller list, with hardware sizes, is on our private AI page.
The architecture behind it
Seen from above, the same five parts appear at every stage.
- A system of record. ERPNext and our CRM hold the customers, projects, invoices and ledgers. If something is not recorded there, it has not happened.
- Agents with a narrow task. Each agent has one job and a short list of permitted actions.
- A gate in code. Validation, limits and consent checks run before anything is written. They do not depend on the model behaving.
- A person at the decision. Drafts wait for review, and the team is told what the agent did.
- A record of every run. The conversation, the outcome and the cost are stored against the business record.
Our reference architecture sets these out in full for technology teams.
What we have learned
- Give an agent one job and a clear finish. Our website agent has three messages and one action. An open-ended assistant is harder to test and harder to trust.
- Put the rule in code, not in the prompt. Every field an agent sends is validated by the server, and tax comes from the supplier record. An instruction in a prompt is a request to the model. It is not a control.
- Plan for the agent failing. If a website conversation ends before the agent has acted, and the visitor left a valid email, a lead is logged anyway with the conversation attached.
- Cap the cost and measure by outcome. Each conversation has a spending limit, and each is recorded with its cost and how it ended: lead logged, requirements started or abandoned.
- Keep test cases. We hold a set of test conversations to run whenever the prompt or the model changes.
- Let agents draft and let people post. Anything that moves money or makes a commitment stops at a draft.
The same pattern in a trading business
A trading company has a different chain and the same structure. An enquiry becomes a quotation, an order, a delivery, an invoice and a collection, and each step has the same in-between work. We have set out that design stage by stage for lead to quote, supplier invoice to payment and collections.
Where to start
Start where we did: with one in-between step that has a clear input, a clear finish and an owner. Put the gate and the record in place from the first day, measure the result against how the work is done today, and extend what works.
If you would like to see how this would look in your business, talk to us.
Vivek Digambernath
Harmonizing the past, present, and future through music, technology, and travel.
From the article to a working brief
No comments yet. Login to start a new discussion Start a new discussion