Capability
AI agents that do the work, not just describe it — reading live data from the systems you already run, drafting the action, and writing back only what a named person has approved. Piloted on one real process in four to six weeks.
From $6,500 · 4–6 weeks · fixed scope, agreed in writing
What your team gets
Not a strategy deck. A running system, the permissions around it, and the code in your repository.
What we build
Most projects need one of these, not all of them. The example under each is a real shape of work, not a category label.
Agents that complete a defined business process end to end — gathering the inputs, applying your rules, and proposing the write. The routine path runs unattended; anything outside it goes to an exception queue where a person decides.
Reconciling a delivery note against the purchase order and flagging only the lines that disagree.
Agents grounded in your own documents and records rather than in what the model remembers. Answers carry citations back to the source paragraph, so a reader can check rather than trust.
Answering dealer questions from the current price list and contract terms, with the clause quoted.
A supervisor that decomposes the work and specialist agents that each own one narrow job. Used where a single prompt chain becomes unreliable — long research tasks, multi-source comparison, work that has to be cross-checked before it is written down.
Our own Market Research Agent: agents that plan, search, read and cross-check before a claim reaches the brief.
A conversational surface over systems your team already uses, with memory of the thread and the same permission model as everything else. The answer is live, because it is read at the moment it is asked.
Asking the operations channel what is in stock in Chattogram and getting the ERP’s answer, not last week’s export.
Turning the PDFs, scans and email attachments that arrive all day into structured records your systems can accept — with a confidence score, and a human check on anything below the line you set.
Reading supplier invoices into the accounting system, routing low-confidence pages to a reviewer.
Agents that watch rather than wait: querying on a schedule, comparing against a rule, and raising the case only when something has actually gone wrong. The cheapest agents to run, and usually the first to pay for themselves.
Catching stock that has gone negative, or an invoice that has aged past its terms, before month end does.
How we build it
Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027. The reason is rarely the model. It is that nobody scoped the integration, nobody would approve a write, and nobody could say afterwards what the agent had done. These five layers exist to remove those three failure modes, in that order.
A connector per system — ERP, CRM, inventory, helpdesk, the internal database nobody documented. Each exposes a named, limited set of operations with a documented contract. The agent never receives a credential.
Permissions are attached to operations, not to models. An agent that can read stock levels cannot silently acquire the ability to change a price, and swapping the underlying model changes nothing about what it may touch.
Model routing with structured output and typed tool calls. Cheap models handle classification and extraction; the expensive one is reserved for the step that actually needs it. Every tool call is schema-validated before it executes.
Reads run at machine speed. Anything that changes a system of record is held in a queue, shown in full — record, field, old value, new value — and committed only when a named person approves it. This is the layer that gets the project past your finance lead.
Every call logged and attributable: who asked, what ran, what returned, who approved it. Evaluation runs against a fixed set of cases on each change, so drift shows up as a failing test rather than as a complaint.
Short-term memory keeps the thread coherent within a task. Long-term memory is a vector store over your own documents, chunked to match how your content is actually structured — a contract is not chunked like a support ticket. Retrieval quality is measured, not assumed: we hold out a set of real questions with known answers and track whether the right passage comes back.
Guardrails sit at three points: before the model, where inputs are validated and prompts are isolated from retrieved content; at the tool boundary, where every call is checked against its schema and the agent’s permissions; and after, where output is validated before anything is shown or written. Retrieved documents are treated as data, never as instructions — which is what stops a poisoned document from redirecting an agent.
A pilot that cannot be measured cannot be extended. Before the build we agree the cases the agent must get right and the numbers that decide whether it worked — accuracy on a held-out set, the share of writes that survive review unedited, and the hours the process used to take. Those numbers are reported at the end, including when they are disappointing.
Where it lands
An agent that answers dealer stock and delivery questions from the ERP, and drafts the replenishment order for a human to approve.
Reconciling production, stock and accounts continuously rather than at month end, raising only the discrepancies.
Removing the re-keying between storefront and ERP, with exceptions routed to the person who can decide.
A member-facing agent that answers from the rulebook and the member record, and drafts renewals for staff approval.
Reading supplier and dispensing documents into structured records, with every low-confidence page checked by a person.
Screening applications against the criteria you wrote down, with the reasoning shown next to each shortlist decision.
Technology
We pick the boring option unless there is a reason not to — the framework is the part most likely to be abandoned before your system is.
How the engagement runs
Every phase ends in a named deliverable. You can stop after any of them and keep what has been built.
Thirty minutes on the process that is costing you. We say whether it is something we would take on and what the realistic shape is — including when the answer is that an agent is the wrong tool.
We map the process as it actually runs and test the integration against your real API or a sandbox rather than assuming it works. This is where most estimates in this category go wrong, so we do it before quoting the build.
Connectors, permission model, retrieval, and the agent itself — built against live data from the first week, with the write queue on. You see it working on your own records, not on a sample.
Evaluation against the cases agreed up front, the approval workflow wired to the people who will actually use it, and handover of the repository with documentation your team can build on.
The pilot either paid for itself or it did not, and the logs say which. If it did, the next process is faster because the access layer is already there. If it did not, you own everything built and owe nothing further.
Why Devs Core
Budge is a finance agent on a customised DeepSeek model, shipped to web, iOS and Android. Market Research Agent is a multi-agent system we use on our own market work. Running them is how we know what an agent costs to operate and where it breaks — which is not knowledge you get from delivery alone.
Unattended write-back into live financial records is not our starting position. It is something you switch on later, per operation, once the log has earned it. Most vendors sell you the demo; the queue is what makes the demo shippable.
Every engagement in an unfamiliar system starts with an integration spike against real data. It is the cheapest two weeks in the project, and it is why our build estimates hold.
100% of the source code, documented, in your repository. No licence fee, no runtime we hold, nothing that stops another team picking it up.
A ten-person team running two or three engagements in parallel. Your pilot is not queued behind forty other accounts, and the person who scoped it is the person who builds it.
If packaged software already covers the problem, or the process is too unstable to automate yet, the audit says so and we withdraw. That answer has cost us work and earned us the call when the package later failed.
Questions
AI agent development is the engineering work of building software that uses a language model to plan and carry out a task against real systems — reading data, calling tools, and producing an outcome — rather than only generating text. In practice most of the work is not the model: it is the connectors to the systems, the permission model that decides what the agent may call, the review step before anything is written, and the logging that makes the whole thing auditable.
A chatbot answers. An agent acts. A chatbot returns text from what it was trained on or what you pasted into it; an agent calls tools against live systems, decides which step to take next, and can change a record. That difference is also why an agent needs permissions, an approval step and an audit log, and a chatbot does not.
Devs Core publishes fixed prices. An agent pilot on a single process starts at $6,500 and runs four to six weeks. The two-week AI Readiness Audit that precedes it is $2,400 and produces the build plan the pilot is quoted from. A full access layer across several systems starts at $8,000. Every figure is a starting point for a scope agreed in writing before work begins.
A pilot against one process, running on live data with an approval queue, takes four to six weeks. The two-week readiness audit before it is what makes that estimate reliable, because the integration is tested against your real API rather than assumed. A multi-system access layer takes five to eight weeks.
Yes, through an access layer rather than direct credentials. Each system is wrapped in a connector exposing a named, limited set of operations, and the agent is granted operations rather than a login. We have connected systems including SAP Business One, Microsoft Dynamics, AutoCount, SQL Account, Odoo, Zoho, Salesforce, HubSpot and Shopify, and we prove the integration in a sandbox before any build is quoted.
Both, but not in the same way. Read operations run immediately. Write operations are held in a review queue that shows the proposed change in full — the record, the field, the old value and the new one — and are committed only when a named person approves. Unattended writes can be enabled later, per operation, once the audit log has shown that operation to be reliable.
Read errors surface in the output where a person can see them. Write errors are caught before they happen, because a write is a proposal until someone approves it. If something does get through, the audit log identifies the call, the input, the output and the approver, so it can be traced and reversed rather than investigated by guesswork. Evaluation against a fixed set of cases runs on every change, so accuracy drift shows up as a failing test.
No. We use commercial model APIs under their no-training terms, or self-hosted open models where data cannot leave your infrastructure at all — which is the right choice when the records are sensitive enough that the question is being asked. Your documents and records are used to answer your queries and for nothing else, and the readiness audit records exactly where each piece of data travels.
LangGraph for stateful orchestration, the Model Context Protocol for tool and system access, and plain typed state machines where a framework would add more risk than it removes. Retrieval runs on pgvector by default, moving to Qdrant or Pinecone when scale or filtering demands it. We pick the boring option unless there is a reason not to, because the framework is the part most likely to be abandoned before your system is.
Yes. The Agent Pilot is one process, end to end, against your real systems, at a fixed price from $6,500 over four to six weeks — including connectors, scoped permissions, the reviewed write queue, audit logging, a measured before-and-after, and full source code. Scope is agreed in writing before work starts and changes go through a process you agreed to.
Thirty minutes, no preparation, no deck. You describe what keeps going wrong and we tell you whether AI is the answer — including when it is not.
Prefer email? contact@devs-core.com