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.
55+
Projects Shipped
100%
Job Success
Top Rated Plus
On Upwork

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.

ApproachBest forMain failure modeEvidence
Deterministic pipeline with LLM stepsClassification, extraction, enrichment on a known sequenceRigid — a new case means a code changeScamMinder: 14 phases, GPT-4o verdicts, 20,000+ domains
Single agent with a tool beltAssisting a human inside an existing workflowWrong tool calls pass silently without argument validationChasr: GPT-4 assistant on a HubSpot pipeline, 50+ reps
Queued background workflowsLong-running generation and publishing at volumePartial failures needing idempotent retriesAI SEO platform: 13 Inngest pipelines, 8 CMS adapters
Retrieval-driven matchingPairing records where judgment beats a SQL filterOutput quality is capped by retrieval qualityContinuity: Claude matching engine, OCR dataroom
Monitoring agent with a human review loopWatching a defined set of signals and proposing the next actionLow precision turns the review queue into alert fatigueGTM signal tool: 20-30 target orgs, human-approved (ongoing)
Autonomous multi-agent swarmOpen-ended research and exploratory tasksErrors compound across hops; spend scales badlyStill not shipped by me. Nearest is the human-reviewed row above

Tech stack

TypeScriptNode.jsNext.jsOpenAI GPT-4oClaude APIOpenRouterInngestPostgreSQLpgvectorSupabaseZodn8nHubSpot APIVercel

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.

How we work

Most MVPs ship in 3–6 weeks; complex platforms are scoped individually once the requirements are clear.

01

Intro Call

A 30-minute conversation about your project, goals, and timeline. No commitment either way.

02

Scoped Proposal

A written scope, architecture outline, and quote. I respond to every message within 24 hours.

03

Weekly Demos

You see working software every week, with written progress updates in between. No black boxes.

04

Ship & Handover

Deployment, documentation, and a clean handover — you own everything I build.

Compliance & standards

GDPR-aware data handlingPII redaction before model callsPer-run token and spend ceilingsAudit log on every tool callHuman escalation paths by design

Frequently asked questions

What is the difference between an AI agent and a chatbot?
A chatbot answers. An agent acts. A chatbot reads your documents and replies in text. An agent calls your CRM, creates the record, checks the response, and retries when the API returns a 500. Almost all the engineering cost sits in that second half: the tool contracts, the permissions, and the failure handling around every call.
Have you shipped autonomous multi-agent systems?
No, and the distinction is worth keeping sharp. The closest is an ongoing GTM signal-intelligence build that monitors 20-30 target organizations, interprets signals in business context, recommends outreach, and improves from reviewer feedback — agent-shaped, but with a person approving every recommendation. Alongside it: a GPT-4 follow-up assistant used by 50+ reps, GPT-4o classification across 20,000+ domains at sub-6-second analysis, and 13 background pipelines coordinating model calls. None of that is a fleet of self-directed agents choosing their own objectives, and I would rather say so than sell you a demo.
Which model should my agent use?
Whichever clears the quality bar most cheaply for each step, which usually means more than one. Routing and classification run fine on small models. Planning and synthesis need a frontier model. I route through OpenRouter so a provider outage becomes a config change rather than an incident, and I measure cost per completed task instead of per token.
How long does an agent build take and what does it cost?
MVPs typically take 3–6 weeks; larger, complex platforms are scoped individually. Most engagements start around $5K; smaller well-scoped work is considered case-by-case. Week one usually goes to scoping tools and failure modes rather than writing prompts, because that is where these projects actually fail. Post-launch support available, and I reply within 24 hours.
What do you need from us to start?
API access to the systems the agent will touch, a written description of the task as a competent human would perform it, and one person who can settle edge cases. If you have logs or tickets from the manual process, send those too. They become the evaluation set that tells us whether the agent is genuinely good.

Ready to start?

Book a free 30-minute call. No sales pitch — just a direct conversation about your project.

Book Free Call

Or email: contact@waseemahmad.dev