AI agent development for systems that do real work, not just a chatbot
Deepsel designs, builds and runs custom AI agents for startups and small businesses. We connect them to the data and tools your team already uses, give them clear limits, and test them against real work before they go live.
The result is not another chat window that gives advice and leaves the task to you. It is software that can:
- Find the right information
- Decide what to do next
- Use approved tools
- Hand uncertain or sensitive decisions to a person
- One useful workflow first, not a platform nobody asked for
- Connections to your CRM, inbox, documents, databases and internal systems
- Evals, permissions, audit logs and human approval where the risk demands them
- A working version every two weeks
- Your code, cloud accounts and data from day one
Our clients
Public and private organizations across the United States and Europe, from startups to government agencies.
What AI agent development actually means
AI agent development is the work of building software that can complete a goal across several steps with a degree of independence.
- Uses an AI model to interpret a request
- Chooses from a limited set of tools
- Acts
- Checks what happened
Continues
Asks a person for help
That makes an agent different from two things it is often confused with:
| System | What it does | Best fit |
|---|---|---|
| Rule-based automation | Follows a fixed sequence: if this happens, do that | Stable, predictable processes with clean inputs |
| Chatbot or assistant | Answers a question or produces content | Information, drafting and simple support |
| AI agent | Chooses steps and tools to complete a task | Multi-step work with judgment, exceptions or unstructured data |
OpenAI describes agents as systems that independently accomplish tasks on a user's behalf; Anthropic draws a similar line between fixed workflows and systems in which the model directs its own process and tool use.
The important word is not “AI.” It is acts.
An invoice agent might
- Read a PDF
- Match the supplier
- Check the purchase order
- Flag a mismatch
- Prepare the record in your accounting system
A support agent might
- Identify the customer
- Inspect their subscription
- Search the knowledge base
- Draft a resolution
- Issue a refund only after approval
Each step is ordinary on its own. The value comes from joining them into one reliable flow.
Custom AI agents we build
The best first agent owns a narrow job with a measurable result.
“Help our operations team”
“Read incoming order emails, check stock, create a draft order and send exceptions to the operations manager”
-
Workflow agents
Workflow agents move work between the systems your team already uses.
They can classify requests, update records, prepare documents, trigger follow-ups and route exceptions without forcing you to replace the underlying software.
AI automation services → -
Knowledge and research agents
These agents search approved documents, databases and outside sources, then return an answer with the evidence behind it.
They fit due diligence, internal policy questions, product research, proposal preparation and other work where the source matters as much as the summary.
-
Customer support agents
A support agent can identify intent, retrieve account context, suggest or send an answer, update the ticket and escalate when confidence is low.
The useful version knows- What it may resolve
- What needs approval
- What must always go to a person
-
Sales and account agents
These agents qualify inbound leads, research accounts, prepare call briefs, update the CRM and draft follow-ups.
They should support a real sales process, not add another stream of generic automated messages.
-
Document-processing agents
An agent can read forms, invoices, contracts, reports and email attachments; extract the fields you need; apply business rules; and send unclear cases for review.
This is where an AI model is often more useful than a fixed parser because real documents rarely stay in one format.
-
Internal operations agents
Operations work is full of small decisions spread across email, spreadsheets, calendars and line-of-business systems.
A custom agent can bring those steps together while keeping the final approval with the person responsible.
Multi-agent systems
Sometimes separate specialist agents are useful—for example, one retrieves evidence, one checks policy and one prepares the action.
Most projects should not start there. A single agent with well-designed tools is easier to test, cheaper to run and simpler to maintain.
We add more agents only when the work genuinely separates into distinct roles.
Our AI agent development services
Custom AI agent development is more than choosing a model and writing a prompt.
The production work sits around the model:
-
Use-case discovery and workflow design
We map the current process, including the exceptions people handle from memory.
Then we define:
- The task the agent will own
- The actions it may take
- The decisions that require approval
- The number that will tell us whether the build worked
-
Data and retrieval
We connect the agent to the right source of truth. That may mean a retrieval-augmented generation system for documents, direct database queries, structured access to a CRM or a pipeline that keeps changing files synchronized.
Access follows the user’s permissions; the agent does not get a master key to the company.
-
Tool and integration development
An agent needs tools to do useful work.
We build controlled connections to your existing:
- APIs
- Databases
- Calendars
- Ticketing platforms
- Payment providers
- Internal software
Each tool exposes a specific allowed action rather than unrestricted access.
-
Agent logic and orchestration
We write the instructions, tool-selection logic, state handling, retries and stop conditions that turn model calls into a working system.
SoftwareWhere a fixed software rule is safer or cheaper, we use one.
AIAI is reserved for the parts that need interpretation or judgment.
-
Guardrails and human approval
More autonomyRead-only tasks
Less autonomy- Refunds
- Payments
- Customer messages
- Changes to production data
We set permissions action by action, validate inputs and outputs, cap loops and spending, and insert approval before high-impact steps.
-
Evaluation and testing
Agents are probabilistic: the same input can produce a different path on another run. Ordinary unit tests are still necessary, but not sufficient. We build a set of representative and difficult cases, run repeated trials, score the result and inspect the full trace of tool calls.
As Anthropic’s guide to agent evals explains, mistakes can propagate across a multi-turn task, so the whole path has to be tested—not just the final sentence.
-
Deployment, monitoring and improvement
We deploy into your cloud account, then:
- Log decisions and tool calls
- Monitor failures
- Turn real corrections into new tests
Models and business rules both change. A production agent needs a visible improvement loop, not a launch-day prompt that nobody touches again.
Deepsel's own AI product experience started with Gemina AI, a coding assistant we built in 2023–2024. It used retrieval to understand a codebase and orchestrated edits across multiple files before today's coding agents were commonplace. We retired it when general-purpose tools caught up.
The lesson was useful: a temporary model advantage is not a moat.
The durable value is the workflow, integrations, data and operating knowledge around it.
Real projects we've shipped
From the Swiss federal login system to consumer apps, marketplaces and company websites: designed, built and run in production by this team.
Clubloungery
Booking.com for nightclubs. Guests pick a lounge directly on the floorplan and reserve in a few clicks; club owners draw their own bookable areas.
FitFoodies
An app to find healthy food around you: fitness-friendly dishes from nearby restaurants on a live map, filtered by dietary tags and nutrition values.
eIAM
The central login of the Swiss federal administration. We replaced the entire front end while the system stayed live, without touching the backend.
Result: Zero downtime during switchover
What production-ready looks like
A convincing demo can be built quickly. Production is where the work begins.
A production agent should have:
-
A defined job
The trigger, inputs, allowed actions and finish state are written down.
-
Least-privilege access
It can read and change only what the workflow requires.
-
A test set made from real cases
Happy paths, messy inputs, missing data, conflicting instructions and attempted prompt injection all belong in it.
-
Human checkpoints
Sensitive, expensive or irreversible actions wait for approval.
-
Traceability
You can see what the agent read, which tools it called and why the task stopped.
-
Fallbacks
Timeouts, unavailable systems and low-confidence results lead somewhere useful.
-
Cost and latency limits
Loops, tool calls and model use are bounded and measured.
-
A rollback path
The agent can be disabled without taking the underlying business process down.
This is why we do not measure an AI agent by how impressive one example looks. We measure it by:
- Completion rate
- Correction rate
- Time saved
- Cost per completed task
- The severity of failures
Why clients choose us
Senior engineers from start to finish
The people on the discovery call are the people who write the code. Nothing is sold by one team and built by another.
Built for production, not for the demo
Every release is tested, monitored and documented before it reaches users. That holds for a first MVP and for a federal login system alike.
Your code, in your accounts
Repositories, cloud accounts and documentation belong to you from the first day. Leaving is a decision, not a migration project.
Small on purpose
A compact senior team and a short client list, so every project gets the founder's attention and nothing waits in a queue.
When custom AI agent development is worth it
A custom build makes sense when the workflow is specific to your business, crosses several systems, depends on private knowledge or creates enough repeated value to justify ownership.
It is usually a good fit when:
- A capable employee spends hours copying information between systems.
- The process contains judgment but also has a clear definition of success.
- Volume is high enough that saved time or faster response can be measured.
- Your existing software exposes APIs or can be integrated safely.
- A packaged AI tool covers only part of the workflow.
- You need control over permissions, data handling, audit history or the user experience.
It is usually the wrong fit when:
- The task happens a few times a month
- The process itself changes every week
- Nobody owns the source data
- One existing product already does the whole job well
In those cases, we will say so. Buying a $50 subscription is better than commissioning software whose only advantage is that it is yours.
Build, buy or combine the two?
Most of our builds are hybrids. Training a foundation model from scratch would be wasteful for almost every startup and small business. We use established models, keep the orchestration and integrations under your control, and preserve the option to change providers when another model performs better.
Our AI agent development process
-
Choose one workflow
We start with the job, not the technology. Together we write the current steps, exception paths, systems involved, baseline cost and success measure.
If the agent cannot be judged, it cannot be improved.
-
Prove the uncertain part
Before building the surrounding application, we test whether the model can do the hardest piece on a small set of real or safely anonymized examples.
AI proof of concept →The output is evidence:
- Accuracy
- Common failures
- Latency
- An initial running-cost estimate
-
Design tools and permissions
We define each piece of data the agent may read and every action it may take. High-risk actions get deterministic validation or human approval.
This is also where we decide whether one agent is enough—which it usually is.
-
Build the working system
The agent is connected to your data and software, wrapped in the interface your team needs and deployed to an environment you control.
Every two weeks ends with a working version you can use, not a slide deck about percentage complete.
-
Test against real cases
We turn examples and failures into a repeatable evaluation suite.
We test:
- Normal work
- Edge cases
- Permissions
- Tool errors
- Hostile inputs
The release threshold is agreed before launch.
-
Launch with limits, then expand
The first release handles a controlled share of work with close monitoring and clear fallbacks. Once the numbers hold, we expand the task, add integrations or increase autonomy.
We do not automate five departments on the strength of one good demo.
What to look for in an AI agent development company
The market is full of firms that can show a chatbot using a tool. The harder question is who can make it dependable inside your business.
Ask every AI agent development company these questions:
- What exact business result will you measure?
“Better productivity” is not a release criterion.
- Who will build the system?
Meet the AI agent developers who will write the code, not only the people selling the engagement.
- What is included beyond the model?
Integrations, interface, permissions, testing, deployment, monitoring, documentation and handover should be explicit.
- How will you evaluate it?
Ask to see the proposed test cases, scoring method and launch threshold.
- Where does human approval sit?
The answer should change with the risk of each action.
- Who owns the code and accounts?
The repository, cloud services, model accounts and logs should be in your name.
- Can we change models later?
A model is a component, not the architecture. Avoid unnecessary provider lock-in.
- What happens when a tool fails or the agent is unsure?
A safe fallback is part of the feature.
- How are running costs measured?
Model calls, retries, search, storage and monitoring need a per-task view.
- What do we receive if we stop?
Code, documentation, test cases, prompts, deployment instructions and data schemas should remain usable.
Deepsel is a compact senior team.
- The people on the discovery call are the people who build and test the system.
- Work happens in your repositories and cloud accounts.
- The scope, estimate and architecture are written down before the build starts.
For a longer checklist that applies to any kind of software project, read how to choose the right software development company.
The technology behind a custom AI agent
We choose the stack for the workflow and the team that will maintain it, not for a framework logo.
A typical system may include:
- Interface
- A web, mobile, Slack, Teams, email or voice interface where the work already happens
- Orchestration
- Python or TypeScript services for orchestration and integrations
- Queues and durable state for long-running tasks
- Models
- A capable model for planning and difficult decisions, plus smaller models for simpler classification or extraction
- Data
- Retrieval over approved documents and structured business data
- PostgreSQL, vector search or both, depending on the information being retrieved
- Connections
- APIs or tightly scoped browser/computer-use tools for legacy systems
The model choice is deliberately replaceable.
OpenAI's practical guide recommends:
- Establish an accuracy baseline with the strongest suitable model
- Then try smaller models where they can still meet the target
That is how we approach cost: measure first, optimize second.
How long does AI agent development take?
-
A proof of concept for one uncertain capability
1 to 2 weeks -
A focused first release that automates one workflow and connects to one or two well-documented systems
Often 4 to 8 weeks -
An agent that crosses several systems, writes sensitive data, supports several user roles or requires compliance work
2 to 4 months or more
The timeline is driven less by the prompt than by the environment around it:
- Are the source documents accurate and accessible?
- Do the systems have usable APIs and test environments?
- How many actions can change customer, financial or operational data?
- Can subject-matter experts provide examples and review failures quickly?
- What accuracy and response time must the agent meet?
We narrow the range during discovery and put the assumptions next to the estimate. If an integration has never been tested, it stays named as a risk rather than disappearing inside a confident date.
What our clients say
Three clients on what it was like to work with us.
“We have worked with Deepsel on many projects over the years. Really easy to work with, fast delivery, proactive problem solver that helps advance projects with creative ideas.”
“Tim did an excellent job in building an app to automate multiple workflows for my van rental business monkeyrent.ch. Thanks to him, I save hours of work every day.”
“Tim is incredibly fast and efficient. I won't hesitate to work with him again in the future.”
How much does AI agent development cost?
Published 2026 vendor ranges are broad.
One current guide puts:
- Proof of concept $5,000 to $15,000
- Focused production agent $15,000 to $40,000
- Integrated business agent $40,000 to $120,000
- Multi-agent or enterprise platform $120,000 to $300,000+
Those are vendor-published ranges, not a market index. They differ because “AI agent” can mean one read-only workflow or a regulated platform with dozens of integrations. Use them to set an order-of-magnitude budget, then ask for the hours, assumptions and exclusions behind your own quote.
Deepsel's published prices
Our pricing is based on the team and time required, and it is public:
-
One-week product and architecture sprint
$3,000 fixedBest fitValidate a use case, audit a prototype, test the risky integration and leave with a written build plan
-
Dedicated senior engineer
$4,000 per month, half-day$8,000 per month, full-timeBest fitYou already have a technical lead and need an experienced builder
-
Fractional CTO with build team
$15,000 per monthBest fitYou need the architecture, product decisions and delivery owned with the build
Fractional CTO services →
Some sample arithmetic—not a quote:
- One full-time senior engineerwhen your team already provides technical direction
- Fractional CTO engagementwith technical leadership and the build team included
- A focused agent that takes one to two months
- A two-to-four-month integrated agent
What changes the price?
Five things move an AI agent development estimate more than the model name:
-
Integrations
Reading from one clean API is different from coordinating several legacy systems with inconsistent data.
-
Autonomy
Drafting for review is cheaper than taking irreversible action, because the second needs stronger permissions, validation and testing.
-
Data readiness
Clean, current documents reduce work. Scanned files, duplicates and conflicting policies create a data project before the agent project.
-
Accuracy and risk
Higher stakes mean larger evaluation sets, more reviews, tighter guardrails and more monitoring.
-
Interface and scale
An internal Slack tool is a smaller product than a customer-facing application with accounts, roles, billing and service-level commitments.
What does an AI agent cost after launch?
The build is not the whole budget. Ongoing costs include:
- Model usage
- Cloud services
- Retrieval or database infrastructure
- Third-party tools
- Monitoring
- Maintenance
Model cost should be measured per successful task, not per API call.
An inexpensive model that retries repeatedly may cost more than a capable model that finishes once.
- Tokens
- Tool calls
- Runtime
- Result
You should also budget for improvement. New cases will expose gaps, source systems will change and model behavior will move. The evaluation set makes those updates controlled: every fix becomes a test that protects the next release.
If the agent is the product you plan to sell, AI MVP development covers that build. For wider market ranges, see our guides to MVP development cost and custom software development cost.
Frequently asked questions
What are AI agent development services?
AI agent development services cover the design, engineering, integration, testing and operation of software agents. A complete service normally includes use-case discovery, data access, tool development, model and orchestration logic, guardrails, evals, deployment, monitoring and support—not only prompt writing.
What is custom AI agent development?
Custom AI agent development builds an agent around your workflow, systems, data and rules. Unlike a general AI product, the agent can use your approved tools, follow your permissions, fit your existing interface and produce an audit history for the work it performs.
How is an AI agent different from a chatbot?
A chatbot returns an answer. An AI agent can decide which steps and approved tools are needed to complete a task, then take those actions. A support chatbot may explain a refund policy; a support agent can inspect the order, check eligibility, prepare the refund and request approval. When an assistant or a fixed workflow is enough, AI automation services covers those as well.
Do we need a multi-agent system?
Usually not at the start. One agent with a small set of clear tools is easier to evaluate, secure and maintain. Multiple agents make sense when the work contains genuinely separate roles that need different context, tools or evaluation criteria.
Can an AI agent connect to our existing software?
Yes, when the software provides an API, database access, webhooks or another controlled interface. Systems without APIs may sometimes be reached through browser automation or computer-use models, but that route needs stronger monitoring because user interfaces change. If the old system is itself the bottleneck, legacy software modernization covers replacing it in stages.
Which AI models do you use?
We select models against the task’s accuracy, latency, privacy and cost requirements. The surrounding system is designed so the model can be changed where practical. Hard tasks may use a more capable model while extraction, routing or classification uses a smaller one.
Will our data be used to train a public model?
Data handling depends on the providers and deployment chosen for the project. We document where data is sent, use business or API terms appropriate to the workload, restrict what the agent can retrieve and keep credentials in accounts you control. If the workload has regulatory or residency requirements, those become architecture requirements before development begins.
How do you keep an AI agent from taking the wrong action?
We limit its tools and permissions, validate proposed actions, require approval for sensitive steps, test repeated runs against real cases, log the full trace and provide a safe fallback. No single guardrail is enough; reliability comes from layers.
Who owns the agent and its code?
You do. Deepsel works in repositories and cloud accounts in your name. The code, prompts, integration logic, tests and documentation stay with you if the engagement ends.
How much does it cost to hire AI agent developers?
At Deepsel, a dedicated senior engineer is $4,000 a month half-day or $8,000 a month full-time. A fractional CTO with the build team is $15,000 a month. A one-week discovery and architecture sprint is $3,000 fixed. The final project cost depends mainly on integrations, autonomy, data readiness and the testing required.