Capability / AI agent development
AI Agent Development Services
AI agent development is the engineering of software that uses a language model to decide which tool to call next in order to complete a task. Quorlytic builds agents connected to internal company data that act with the requesting user's permissions, use a small set of scoped tools, require approval for irreversible actions and record every consequential step.
By QuorlyticUpdated
An agent that can call tools is a system with authority, so the authority is designed first. Start with a bounded task, the smallest useful set of tools and a clear rule for what needs a human's approval.
Request
- Task from a userIdentity, role and purpose travel with it
Per-user permissions · step and cost limits
- Planning modelChooses the next step
- Scoped toolsSearch · read · draft · update
Action
- ReversibleRead and draft: runs
- IrreversibleSend, delete, pay: approval first
- Audit trailTools, data read, approver
- EvaluationStop, escalate and refuse cases
The business problem
An agent earns its complexity only when the path through a task varies and cannot be scripted in advance. If the steps are known, a deterministic workflow is cheaper to run, easier to test and simpler to audit; if the task is answering questions, a search assistant with no write access is enough. Most first deployments should be read-only, with autonomy added where the measured benefit justifies the controls it needs.
What we build
The common thread is an agent working inside an organisation's own systems and data, under the same access rules people already have. Typical builds include agents that answer and act across internal documents and databases, agents that prepare work for a person to approve, and agents that query governed warehouse data through an agreed semantic layer rather than raw tables.
The outcome
A bounded agent in production with per-user access, approval gates and an audit trail
Agent run trace
One agent task, followed through every control.
A production agent is judged by what it did and on whose behalf. The trace follows a single task from request to record: identity, plan, tool calls, the action that needed approval and the audit entry it left behind.
- Service desk agent
- Read and draft
- Approval required to send
- RequestA support lead asks for a refund summary on an open ticketLogged with the user, role and purposeReceived
- IdentityTask runs with the support lead's permissionsNo shared service accountScoped
- Tool callRead ticket and order historyAllow-listed read tools onlyTwo records read
- DraftRefund summary and a proposed customer replySources attached to the draftDrafted
- Proposed actionSend the reply to the customerIrreversible, so approval is requiredAwaiting approval
- RecordInputs, tools, data read and approver loggedRetained for audit and reviewRecorded
What it answers
- Whose permissions did the agent use?
- Which actions did it take on its own?
- Who approved what it sent?
When this is the right engagement
Symptoms that bring teams here.
These are the situations in which an AI agent is worth building, and the ones that usually mean a simpler tool will do.
People copy information between the same systems every day
A bounded, repetitive task across known tools is where an agent with scoped access earns its place.
A pilot chatbot answers well but cannot do anything
The next step is controlled action: scoped tools, approval gates and an audit trail.
The agent demo used an admin account
In production it must act with each user's permissions, or it becomes the easiest way to leak data.
Nobody can say what the agent did yesterday
Without a trace of tool calls, data read and approvals, an agent cannot be operated or trusted.
Every step of the process is already known
A deterministic workflow will be cheaper and easier to test than an agent. Start there.
Security has blocked the AI project
The objection is usually access and audit. Designing those first is what gets an agent approved.
Capability model
What a production agent needs.
A production agent is five engineered responsibilities around a model. Select one to see what it involves and what it produces.
01 — Task
Bound the job: who asks, what the agent may do, what success looks like and what failure costs.
What it produces
A written task definition with the actions the agent may and may not take.
What usually goes wrong
- A general assistant with no defined task
- No agreed definition of done
- Autonomy chosen before the failure cost is known
Technologies in this stage
- Task definition
- Success criteria
- Failure-cost review
02 — Tools & access
Give the agent the smallest useful set of tools, each acting with the requesting user's identity.
What it produces
A tool inventory and permission model enforced by the source systems.
What usually goes wrong
- Shared service accounts with broad access
- Raw database access instead of purpose-built tools
- Permissions enforced by prompt instructions
Technologies in this stage
- Scoped APIs
- OAuth delegation
- Allow-listed tools
- MCP servers
03 — Control
Require approval for anything irreversible and cap steps, tool calls and spend per task.
What it produces
Approval rules, limits and a defined fallback for every task.
What usually goes wrong
- Irreversible actions taken without review
- Runaway loops and repeated tool calls
- No fallback when the agent cannot finish
Technologies in this stage
- Approval gates
- Step and cost limits
- Fallback paths
04 — Evaluate
Test the agent on real tasks, including the ones where the right action is to stop, escalate or refuse.
What it produces
An evaluation set and release gate re-run before every change.
What usually goes wrong
- Testing only the happy path
- No permission-denied cases
- Changing the model or prompts without re-testing
Technologies in this stage
- Task evaluation sets
- Permission tests
- Release gates
05 — Operate
Log every consequential action, monitor behaviour and cost, and keep a rollback that has been exercised.
What it produces
An audit trail, monitored signals with owners and an exercised rollback.
What usually goes wrong
- No record of what the agent read or did
- Cost growing unnoticed with usage
- No owner for agent incidents
Technologies in this stage
- Audit trail
- Monitoring
- Cost tracking
- Rollback
Reference architecture
An agent inside its controls
The model sits in the middle, but most of the architecture is the control around it: identity carried into every call, scoped tools, a gate on irreversible actions and a record of everything consequential.
Request with identity
The user's identity and role travel with the task.
- SSO
- Role
- Purpose
Planning model
Decides the next step within the task's limits.
- Step limit
- Cost limit
- Task scope
Scoped tools
Purpose-built actions, never raw admin access.
- Search
- Read record
- Draft
- Update
Company data
Read with the user's permissions, enforced at source.
- Documents
- Warehouse
- CRM
- Ticketing
Approval gate
Irreversible actions wait for a named approver with the evidence.
- Send
- Delete
- Pay
- Publish
Audit and monitoring
Every consequential action recorded and watched.
- Tool calls
- Data read
- Approvals
- Cost
Across every step
- Per-user permissions
- Evaluation set
- Step and cost limits
- Exercised rollback
The approach
- 01
When a task needs an agent, and when it does not
An agent earns its complexity only when the path through a task varies and cannot be scripted in advance. If the steps are known, a deterministic workflow is cheaper to run, easier to test and simpler to audit; if the task is answering questions, a search assistant with no write access is enough. Most first deployments should be read-only, with autonomy added where the measured benefit justifies the controls it needs.
The interaction patterns are compared in depth in AI agents: when autonomy works.
- 02
Agents we build on company data
The common thread is an agent working inside an organisation's own systems and data, under the same access rules people already have. Typical builds include agents that answer and act across internal documents and databases, agents that prepare work for a person to approve, and agents that query governed warehouse data through an agreed semantic layer rather than raw tables.
- Internal-knowledge agents combining retrieval with scoped actions
- Workflow agents that draft, check and route work for approval
- Data agents that query governed models through a semantic layer
- Agents connected to CRM, ERP, ticketing and document systems through allow-listed tools
- 03
Access is enforced per user, not per agent
An agent acting on someone's behalf must never see or do more than that person can. Each request carries the user's identity into every tool call and data query, so permissions are enforced by the source systems rather than by instructions in a prompt. A shared service account with broad access is the most common way an agent leaks data, and it is designed out from the start.
- 04
Approval gates for anything irreversible
Read actions and reversible drafts can run automatically; sending, deleting, paying, publishing and changing records of consequence go through an explicit approval step with the evidence the agent used. Steps, tool calls and spend are capped per task, so a confused agent stops rather than loops.
- Irreversible actions require a named approver
- Step, tool-call and cost limits set per task
- A defined fallback when the agent cannot complete the task
- 05
Evaluation before autonomy
An agent is tested on a task set drawn from real work, including cases where the right action is to stop, escalate or refuse, and cases where a user lacks permission. Tool selection, task completion, unsafe-action attempts, latency and cost are measured separately, and the set is re-run before every change to the model, prompts or tools.
Retrieval quality is scored with the methods in evaluating RAG systems, because an agent that reads the wrong document acts on the wrong facts.
- 06
Audit, monitoring and rollback
Every consequential action is logged with its inputs, the tools called, the data read, who it acted for and who approved it. After launch the agent is monitored for task success, escalation and refusal rates, unusual tool use and cost, with an owner for each signal and a rollback to the previous configuration that has been exercised.
The controls are set out as a framework in the AI agent governance guide.
- 07
What drives the cost of an AI agent
Cost is driven less by the model than by the systems the agent must reach and the controls around them: the number of tool integrations and their authentication, the condition of the data the agent reads, the strictness of the evaluation standard, the approval workflow, and the expected volume of tasks, which sets running cost. A first agent is scoped as a bounded pilot on one task, priced as a fixed scope agreed in writing.
- 08
An agent is only as reliable as the data it reads
Agents fail quietly when the documents are stale, the metrics are undefined or the permissions are wrong. That is why agent work at Quorlytic starts from the data foundation: governed models, documented definitions and tested access. The published case studies describe that foundation work for manufacturing and healthcare clients; agent engagements build on the same practice.
Delivery model
How the work is sequenced.
Four phases. Autonomy is added only where the evaluation shows it is safe.
| Phase | Activities | Decisions made here | What you keep |
|---|---|---|---|
| Bound the taskDecide what the agent is for and what it may do. |
|
| Task definition and action policy |
| Scope tools & accessConnect the agent safely to company systems. |
|
| Tool inventory and permission model |
| Evaluate behaviourProve it behaves on real work. |
|
| Evaluation results and release gate |
| Deploy & monitorRun it with an owner and a way back. |
|
| Production agent with audit trail and runbook |
Technology fit
What each technology is here to do.
What is involved, by role. Models and frameworks are chosen against the task's evaluation set, not the other way round.
Models
- Hosted frontier models
- Open-weight models
- Model gateways
Chosen on quality, latency, cost and data-residency for the specific task.
Orchestration
- Agent frameworks
- Tool calling
- Workflow engines
Holds the plan, the limits and the state of a run, and makes each step inspectable.
Data and tools
- Enterprise search
- Warehouse semantic layer
- Business APIs
What the agent reads and acts on, under the same access rules people already have.
Platform detailControl
- Identity provider
- Approval workflow
- Audit log
- Evaluation set
The part that makes an agent safe to run in production and possible to approve.
Technology marks belong to their respective owners. No partnership, certification or endorsement is implied.
Engineering concerns
What has to be answered before it is trusted.
What has to be true before an agent is given real work.
- Least privilege
- The agent never sees or does more than the person it acts for, enforced by the source systems.
- Prompt injection
- Retrieved text is treated as untrusted input, and no instruction inside a document can widen the agent's permissions.
- Irreversible actions
- Sending, deleting, paying and publishing go through a named approver with the evidence the agent used.
- Runaway cost
- Step, tool-call and spend limits per task, so a confused agent stops rather than loops.
- Explainability
- Every consequential action can be traced to its inputs, tools, data read and approver.
- Data residency
- Where prompts, documents and logs are processed and retained is decided before the model is chosen.
Search, workflow or agent: which pattern fits the task
| Dimension | Search assistant (RAG) | Deterministic workflow | Workflow with approval | Bounded agent |
|---|---|---|---|---|
| Who decides the next step | The user; the system only answers | Fixed code paths | Fixed code paths, with a person approving the final action | The model, within the tools it is given |
| Authority it holds | Read-only, within the user's permissions | Whatever the workflow is coded to do | Proposes; a person commits | Calls scoped tools, with approval for irreversible actions |
| Best fit | Answering questions from permitted documents | Known, repeatable steps | Known steps with a consequential end action | Tasks whose path varies and cannot be fully scripted |
| Main risk | Unsupported or wrongly cited answers | Brittleness when inputs change | Approval fatigue | Wrong tool calls and runaway loops |
Where it applies
Related work, and why it is related.
Where agents connect to the rest of the platform, and the guides behind the controls.
- Enterprise RAG developmentMost useful agents start with permission-aware retrieval over company documents.
- AI and machine learningThe parent service: bounded tasks, evaluation and production operation.
- Data engineeringAgents are only as reliable as the governed data and definitions they read.
- AI agent governanceThe eight controls behind per-user access, approval and audit.
- Managed data and AIMonitoring, incident response and change control once the agent is live.
- HealthcareWhere least-privilege access and audit trails are a precondition, not a feature.
Questions
Questions worth asking.
What do AI agent development services include?
Defining a bounded task, designing the tools and the permission model, connecting the agent to internal systems with the user's identity, building approval gates for irreversible actions, creating an evaluation set from real work, and deploying with monitoring, cost limits, an audit trail and a rollback path.
Has Quorlytic built AI agents for clients?
Yes. Quorlytic has built AI agents for client teams. Client details are not published without each client's approval; the engineering approach is set out on this page and in the agent governance guide, and specific work can be discussed directly.
How much does it cost to develop an AI agent?
It depends on the number of systems the agent must reach, the condition of the data it reads, the evaluation standard, the approval workflow and the expected task volume, which drives running cost. A first agent is a bounded pilot on one task, priced as a fixed scope agreed in writing; tell us the task and the systems involved and we will give you a range.
Can an AI agent use our internal data safely?
Yes, if it acts with the requesting user's identity rather than a shared account, uses only allow-listed tools, needs approval for irreversible actions and logs what it did. Permissions are then enforced by your source systems, not by instructions in a prompt.
Do we need an agent, or would a workflow do?
If the steps are known in advance, a workflow is cheaper and easier to test. Choose an agent only when the path genuinely varies and cannot be scripted, and keep a person approving any action that cannot be undone.
Which models and frameworks do you use?
The ones that meet the task's quality, latency and cost envelope on your own evaluation set, deployed where your data-residency and security requirements allow. Quorlytic holds no partner status, reseller agreement or certification with any model or platform vendor, so the recommendation follows the task.
Next step
Discuss your first AI agent.
Describe the task, the systems the agent would need to reach and who would approve its actions. That is enough to scope a first agent.