Service · AI Agents
AI Agent Development
Systems that call your tools and act, not demos that answer questions.
An AI agent plans, calls tools, checks the result, and either continues or hands the job to a person. I build them the way I build any production system: typed tool contracts, validated arguments, retries, spend caps, and logs you can read after the fact. The experience behind that is real production LLM orchestration, including a GPT-4 follow-up assistant used by 50+ reps and a classification pipeline that has processed 20,000+ domains.
Most teams asking for an agent need a deterministic pipeline with two LLM steps inside it, and that pipeline will be cheaper, faster, and debuggable at 3am.
TL;DR
- AI agent development covering tool and function calling, structured outputs, retry policy, human escalation, evaluation sets, and per-request spend caps.
- Shipped LLM orchestration: Chasr put a GPT-4 follow-up assistant on a HubSpot sales pipeline for 50+ reps, saving 10 hours per rep per week and lifting follow-ups 60%.
- ScamMinder runs a 14-phase verification pipeline with GPT-4o scam-risk classification across 20,000+ domains, sub-6s analysis, 99.9% uptime.
- Honest scope: what I have shipped is LLM pipelines, assistants, and an agent-shaped signal-intelligence tool with a human review loop — not autonomous multi-agent swarms. I will not sell you a receipt I do not have.
- Most engagements start around $5K; smaller well-scoped work is considered case-by-case. MVPs typically take 3–6 weeks; larger, complex platforms are scoped individually.
The challenge
Agent projects rarely fail at the model. They fail at the seams. A tool gets called with an argument the API rejects and nobody notices for a week because the failure was swallowed by a try/catch. A retry duplicates a record. A run loops nineteen times on an ambiguous instruction and nobody sees the spend until the invoice. Meanwhile the demo that won internal approval ran once, on clean data, with a human watching. Real inputs are messy, real APIs return 500s at 2am, and real users ask the system to do things the prompt never anticipated. The fix is unglamorous: define the tools before the prompts, validate every argument against a schema, make every action idempotent, cap steps and spend per run, log every hop, and decide up front which decisions a human still signs off on. Teams that skip this ship a prototype and then spend three months turning it into software.
What I build
Agent Architecture Review
A written recommendation on how much autonomy your task actually warrants, which steps stay deterministic, and where the model belongs
Tool & Function Calling Layer
Schema-validated tool definitions, idempotent actions, permission boundaries, and typed error handling on every external call
LLM Pipeline Engineering
Multi-step pipelines on durable background jobs with retries, fallbacks, structured outputs, and provider routing
Retrieval for Agent Context
Chunking, embeddings, hybrid search, and re-ranking so the agent reasons over your data instead of guessing
Guardrails, Evals & Observability
Evaluation sets from your real cases, per-run traces, step and budget ceilings, and human escalation paths
CRM & Systems Integration
Wiring agents into HubSpot, internal APIs, and existing databases so they fit the workflow your team already uses
What does an AI agent actually do in production?
A production agent receives a goal, picks from a fixed set of tools, calls them with validated arguments, inspects the result, then continues or escalates to a human. Every step is logged. The hard engineering is not the prompt. It is the tool contracts, the retry policy, and the stop conditions.
The prompt is maybe five percent of the work. The rest is the boring layer nobody demos: a schema for every tool argument so the model cannot pass a malformed record into your CRM, idempotency keys so a retry does not create the same deal twice, timeouts so one slow API does not stall a run, and a budget ceiling per task so a loop costs you dollars instead of a bill you find out about on Friday.
On Chasr, the useful part was never the model. It was fitting GPT-4 follow-up assistance inside an existing HubSpot workflow so reps did not have to change tools. Reps abandon anything that adds friction. The result was measured in recovered hours, not in a new dashboard: 10 hours saved per rep per week across 50+ reps, follow-ups up 60%, and $100K+ of capacity recovered per quarter.
When is an agent the wrong answer?
When the task has a known sequence. If a human would follow the same seven steps every time, write those seven steps in code and use the model only where judgment is required. Agents earn their cost on branching, ambiguous work. On fixed work they add latency, spend, and a new class of silent failure.
ScamMinder is the clean example. Deciding whether a domain is a scam sounds like agent work. It is not. It is 14 deterministic verification phases feeding signals into a single GPT-4o classification step. That design is why it holds sub-6-second analysis at 20,000+ domains and 99.9% uptime. An agent free to choose its own path would have been slower, more expensive, and impossible to explain to a user disputing a verdict.
My first deliverable on most engagements is a written recommendation on how much autonomy the system should actually have. Sometimes that recommendation is that you do not need an agent at all. That conversation costs you an hour and saves a quarter.
How do you stop an agent from looping or burning budget?
Hard limits, not good intentions. A maximum step count per run, a token and dollar ceiling per task, timeouts on every tool call, and a cheaper model for the steps that do not need a frontier one. Anything that exceeds a limit stops and escalates to a human with its full trace attached.
Cost control is an architecture decision, not a setting. Route each step to the cheapest model that clears its quality bar, cache anything deterministic, push long work into queued background jobs instead of holding an HTTP request open, and measure spend per completed task rather than per token. The AI SEO platform runs this shape at scale: 13 Inngest background pipelines, 8 CMS adapters behind one publishing interface, 100 API routes, and 74 test files.
Provider routing matters as much as model choice. Running LLM calls through OpenRouter means a provider outage or a price change is a config edit rather than an incident. Every run writes a trace, so when an output is wrong you can see which tool returned what, and fix the actual cause instead of rewriting the prompt and hoping.
What proof do you have that this works outside a demo?
Five systems using LLMs under real load: Chasr, ScamMinder, an AI SEO content platform, Continuity — a Belgian M&A marketplace with a Claude-powered matching engine, an OCR dataroom, and 4 registry API integrations — and an ongoing GTM signal-intelligence build for a B2B SaaS team. None of them is an autonomous multi-agent swarm, and I will not describe them as one.
The GTM build is the closest of those to agent work, so it is worth being exact about. It monitors 20-30 target organizations, interprets what it finds in business context rather than pattern-matching keywords, recommends who to contact and why, and improves from the reviewer's corrections in a review UI. Monitor, interpret, recommend, learn — that is agent-shaped. What it is not is autonomous: a person approves before anything leaves the building, and the engagement is ongoing rather than a finished deployment. The distinction is not pedantry. A human-gated recommender and a fleet of self-directed agents have different failure modes, different spend profiles, and completely different review burdens.
That distinction is the whole point of this page. Deep production experience with LLM orchestration, tool calling, retrieval, background pipelines, and cost control transfers directly to agent work. It is not the same claim as having run a fleet of self-directed agents in production, and a developer who blurs those two things will blur other things later.
If you are interviewing agencies for agent work, ask each one which specific system they shipped, how many steps it took autonomously, and what happened the first time it failed. The answers separate engineering from marketing quickly.
Agent architectures and when each earns its keep
Qualitative tradeoffs, plus which shipped project each pattern comes from. The last row is capability framing, not a receipt.
| Approach | Best for | Main failure mode | Evidence |
|---|---|---|---|
| Deterministic pipeline with LLM steps | Classification, extraction, enrichment on a known sequence | Rigid — a new case means a code change | ScamMinder: 14 phases, GPT-4o verdicts, 20,000+ domains |
| Single agent with a tool belt | Assisting a human inside an existing workflow | Wrong tool calls pass silently without argument validation | Chasr: GPT-4 assistant on a HubSpot pipeline, 50+ reps |
| Queued background workflows | Long-running generation and publishing at volume | Partial failures needing idempotent retries | AI SEO platform: 13 Inngest pipelines, 8 CMS adapters |
| Retrieval-driven matching | Pairing records where judgment beats a SQL filter | Output quality is capped by retrieval quality | Continuity: Claude matching engine, OCR dataroom |
| Monitoring agent with a human review loop | Watching a defined set of signals and proposing the next action | Low precision turns the review queue into alert fatigue | GTM signal tool: 20-30 target orgs, human-approved (ongoing) |
| Autonomous multi-agent swarm | Open-ended research and exploratory tasks | Errors compound across hops; spend scales badly | Still not shipped by me. Nearest is the human-reviewed row above |
Tech stack
Which of my builds proves this
Read this before the cards. These projects prove production LLM orchestration: tool calling, classification, retrieval, background pipelines, and cost control under real load. One of them is genuinely agent-shaped — a GTM signal-intelligence tool that monitors a defined set of organizations, interprets what it sees in business context, recommends an action, and improves from a reviewer's correction. That one is an ongoing engagement with a person approving every recommendation, which is deliberately not the same thing as an autonomous multi-agent system. None of these is described as a swarm, because none of them is one. Treat them as the engineering an agent is built from, plus one system that acts like an agent under human review.
GTM Signal Intelligence — Agent-Shaped, Human-Reviewed
Ongoing engagement for a B2B SaaS team: monitors 20-30 target organizations, interprets signals in business context, recommends outreach, and learns from reviewer feedback.
Read case study →Chasr — GPT-4 Sales Assistant
GPT-4 follow-up assistance wired into a HubSpot pipeline for 50+ reps: 10 hours saved per rep per week, follow-ups up 60%, $100K+ capacity recovered per quarter.
Read case study →ScamMinder — 14-Phase Classification Pipeline
Deterministic verification phases feeding a GPT-4o scam-risk verdict: 20,000+ domains analyzed, sub-6s analysis, 99.9% uptime.
Read case study →AI SEO Platform — LLM Orchestration at Volume
13 Inngest background pipelines, 8 CMS adapters, LLM orchestration through OpenRouter, 100 API routes, and 74 test files.
Read case study →Related services
RAG & LLM Development
Retrieval over your own data, with citations and an evaluation set that catches regressions.
Explore →MCP Development
Model Context Protocol servers that expose your internal tools to agents safely.
Explore →AI Chatbots
When the job is answering rather than acting, a hardened chatbot is the cheaper build.
Explore →How we work
Most MVPs ship in 3–6 weeks; complex platforms are scoped individually once the requirements are clear.
Intro Call
A 30-minute conversation about your project, goals, and timeline. No commitment either way.
Scoped Proposal
A written scope, architecture outline, and quote. I respond to every message within 24 hours.
Weekly Demos
You see working software every week, with written progress updates in between. No black boxes.
Ship & Handover
Deployment, documentation, and a clean handover — you own everything I build.
Compliance & standards
Frequently asked questions
What is the difference between an AI agent and a chatbot?
Have you shipped autonomous multi-agent systems?
Which model should my agent use?
How long does an agent build take and what does it cost?
What do you need from us to start?
Ready to start?
Book a free 30-minute call. No sales pitch — just a direct conversation about your project.
Book Free CallOr email: contact@waseemahmad.dev