Service S·01

AI Agent Development

Production LangGraph agent systems for SaaS founders and operations teams: tool-calling agents, multi-agent workflows, and human-in-the-loop pipelines — designed and built by Rohan Jalil.

Last reviewed: 24 July 2026

01 · Definition

What is AI agent development?

AI agent development is the engineering of software systems in which a large language model plans work, calls tools, and carries state across multiple steps to complete a task end-to-end. Rohan Jalil is an AI agent developer who designs and builds production agent systems on LangGraph: tool-calling agents, multi-agent workflows using supervisor and planner–executor patterns, and human-in-the-loop pipelines where a person approves consequential actions before they run. Typical clients are SaaS founders and operations teams replacing repetitive knowledge work — screening, routing, drafting, reconciling — with an agent that does the work and shows its reasoning. Every build ships with the safeguards production demands: approval gates, decision observability, per-run cost budgets, and an evaluation harness that gates each release.

The discipline sits closer to distributed-systems engineering than to prompt writing. A working demo takes an afternoon; a system that runs unattended against real customer data needs explicit state, bounded costs, and a way to replay any decision it made. That gap — demo to dependable — is the part of the work this service covers.

Rohan has been building backend and full-stack systems since 2010, and since 2023 has focused on production agent architecture. The largest documented build is a 47-node LangGraph workflow that reduced HR screening overhead by 75%.

02 · Agent vs chatbot

When do you need an agent instead of a chatbot?

A chatbot answers; an agent acts. If the work involves several dependent steps, systems that must be updated, or decisions that need an audit trail, a linear chatbot will plateau quickly. The differences are structural, not cosmetic.

Dimension	Linear chatbot	Agent workflow
Task decomposition	One prompt in, one answer out; the user breaks the work into pieces	The agent plans — a goal is split into steps and executed in sequence
State	Chat history only; context is lost between sessions	Explicit state object, checkpointed at every node; runs resume mid-task
Control flow	Fixed request–response; no branching	Conditional branches, loops, retries, and parallel tool calls in the graph
Auditability	A transcript of messages	Full decision log — every node, tool call, and approval is replayable
Cost control	Per-message spend, hard to bound in advance	Per-run token budget, model routing, and hard caps enforced in the graph

A practical test: if the deliverable is an answer, a chatbot — often a RAG assistant — is the right shape. If the deliverable is completed work inside your CRM, ATS, or ticketing system, you need an agent workflow with tool access and approval gates.

03 · Architecture

What does a production agent architecture include?

Six layers, all present in every build. Skipping any one of them is how agent projects end up stalled in pilot.

Orchestration	LangGraph state machine — supervisor or planner–executor pattern, checkpointing at every node, resumable runs, deterministic replay of any execution
Tool layer	Typed tool-calling interfaces to your APIs and databases; least-privilege credentials per tool; idempotency keys so a retried write never duplicates a side effect
Approval gates	Human-in-the-loop interrupts before consequential actions — outbound messages, record changes, anything customer-facing — with a review UI and an audit trail
Observability	Tracing on every node and tool call, decision replay for debugging and disputes, alerting on failure rates and output drift
Cost controls	Per-run token budgets with hard caps, model routing (small models for cheap deterministic steps), caching for repeated retrievals, cost-per-task reporting
Evals	Evaluation harness — golden datasets, regression suites, and pass/fail thresholds wired into the release process; no eval pass, no deploy

This is the same architecture documented in the HR screening case study: multi-agent screening with approval points, retrieval over role rubrics, and full decision replay.

04 · Process

How is an agent build delivered?

Five steps, each with a concrete artefact. The riskiest technical question is answered in week two or three — not discovered in month three.

Step 01 · Discovery

Map the workflow and define success

We document the current process step by step, agree the metrics that define success, and mark every action that must pause for human approval. Artefact: a written workflow map and success criteria.

Step 02 · Architecture spike

Prove the riskiest part first

A one-to-two-week thin slice that exercises the hardest question — usually the trickiest tool integration or the least reliable reasoning step. Artefact: a running spike and a go/no-go recommendation with a firmer estimate.

Step 03 · Build

Graph, tools, and approval lanes

The LangGraph state machine, the typed tool layer against your systems, the approval UI, and staging deployment. Progress ships in reviewable increments, not a single reveal.

Step 04 · Evaluation harness

Measure before trusting

Golden datasets built from real historical cases, regression suites for accuracy and cost, and release gates. The agent earns wider autonomy only as the numbers support it.

Step 05 · Handover

Runbook and operating docs

A written runbook covering failure modes, escalation paths, budget alarms, and how to extend the graph — plus a walkthrough with your team. You own the system and can operate it without me.

05 · FAQ

Common questions about AI agent development

Which framework do you use — LangGraph or CrewAI?

LangGraph for most production builds, because its explicit state graph makes control flow, checkpointing, and human approval gates first-class — the 47-node HR screening workflow is a representative example. CrewAI and AutoGen are better fits for fast prototypes and role-based collaboration experiments, and I use them when speed of iteration matters more than replayability. The choice is settled during the architecture spike, against your workload, not by default.

How do you keep agent costs under control?

With per-run token budgets enforced inside the graph, so a runaway loop hits a hard cap instead of a surprise invoice. Cheap deterministic steps route to small models or to no model at all; repeated retrievals are cached; and the evaluation harness reports cost per task alongside accuracy, so a cost regression blocks a release the same way a quality regression does. You see projected monthly spend before go-live, not after.

Can the agent take actions in my systems safely?

Yes — behind approval gates. Reads run freely; consequential writes such as sending a message, changing a CRM record, or advancing a candidate pause the run until a human approves them in a review UI. Every tool gets least-privilege credentials and idempotency keys, so a retry never duplicates a side effect. You decide which action types are gated, and gates are relaxed per action type as the eval numbers justify it.

How long does an agent build take?

Typically six to twelve weeks end to end, depending on how many tools the agent needs and how complex the approval flows are. The architecture spike takes one to two weeks and exists precisely to firm up that range: a single-workflow agent with a handful of tools lands near the lower bound, while multi-agent systems with several integrations and a custom approval UI take longer. I quote a committed range after the spike, not before.

06 · Related

Related work & services

CS·01

07 · Next step

Work with Rohan on your next AI build.

Hire on Upwork → Email Rohan