AI agents are no longer just prompt wrappers. A production agent must manage state, select tools, recover from failures, handle permissions, cite evidence, and complete tasks consistently. The best dev tools for building agents are therefore not a single framework or model. They are a layered engineering stack that makes agent behaviour inspectable and controllable.
For Indian builders, the right stack also needs to account for cost-sensitive inference, multilingual inputs, data residency, intermittent integrations, and enterprise security reviews. Start with the smallest architecture that can complete the job, then add complexity only when traces and evaluation results justify it.
What an agent development stack must solve
A dependable agent stack usually covers six capabilities:
- Orchestration: define state, steps, branching, retries, and human approval.
- Tool execution: connect APIs, databases, browsers, code runtimes, and business systems safely.
- Memory and retrieval: preserve useful user context without storing everything indiscriminately.
- Observability: trace model calls, tool calls, latency, errors, and cost.
- Evaluation: test task completion, factuality, safety, and regression behaviour.
- Deployment and governance: control secrets, permissions, audit logs, and scaling.
Voice and multimodal products need additional streaming and interruption handling. If that is your use case, compare this stack with the architecture in How to Build a Voice Agent: Architecture, Tools and Costs.
Orchestration frameworks: control the agent loop
LangGraph for explicit state and durable workflows
LangGraph is a strong choice when an agent needs loops, checkpoints, conditional branches, and resumable execution. Its graph model makes the workflow visible: a node may retrieve data, call a tool, ask for approval, or route to a fallback. This is more maintainable than hiding all behaviour inside a generic agent.run() call.
Use it for support automation, research pipelines, coding agents, and operations workflows where every step matters. Persist state at meaningful boundaries, define maximum iterations, and make retries idempotent. LangGraph is particularly useful when a task may pause for a user or operator and resume later.
CrewAI for role-based multi-agent workflows
CrewAI is suited to teams of specialised agents, such as a researcher, analyst, writer, and reviewer. It can speed up prototyping for market intelligence, content operations, and structured research. However, multi-agent design adds latency, token cost, and more failure points.
Do not create multiple agents simply because the framework makes it easy. Use separate agents only when roles require different tools, prompts, permissions, or evaluation criteria. For more advanced collaborative coding patterns, see Build Swarm-Based IDE Agents.
PydanticAI for typed, validated outputs
PydanticAI is valuable when tool arguments and final outputs must conform to strict schemas. Typed models make invalid dates, missing fields, malformed API parameters, and unexpected enum values easier to catch before they reach downstream systems.
This is a practical fit for fintech, healthcare, logistics, and government workflows. Validation is not a substitute for business rules: validate both the model output and the action’s authorisation, limits, and side effects.
Tool execution and sandboxing
An agent with access to email, payments, customer records, or code execution is an application with privileged capabilities. Treat every tool as an API surface, not as a prompt feature.
- Give each tool a narrow input schema and a clear timeout.
- Separate read-only tools from write or delete operations.
- Require confirmation for irreversible actions.
- Use scoped credentials rather than shared administrator tokens.
- Record the user, agent run, tool arguments, result, and approval decision.
For code execution, E2B provides isolated cloud sandboxes for tasks such as Python analysis, document transformation, and chart generation. Docker can work for controlled workloads, but containers are not automatically a strong security boundary. Use hardened images, resource limits, network restrictions, ephemeral storage, and a separate execution service.
Composio can reduce integration work by providing agent-oriented connectors for services such as GitHub, Slack, Google Workspace, and CRM platforms. Review each connector’s permissions and authentication flow before enabling it for production users. For distributed tool-heavy systems, Building Distributed Systems with AI Agents provides a useful architectural lens.
Memory, retrieval, and data boundaries
Most agents do not need unlimited memory. They need the right context at the right time.
Use short-term state for the current task, a relational database for durable business records, and retrieval for relevant documents. A vector database such as Qdrant, Weaviate, or Pinecone can support semantic search, but embeddings alone do not solve access control. Filter results by tenant, user, document permissions, language, and recency before sending them to a model.
Tools such as Mem0 and Zep can extract durable facts from conversations. Apply them selectively: store preferences or stable profile information only when there is a clear product benefit, provide deletion controls, and avoid inferring sensitive attributes. For Indian deployments, map where prompts, retrieved documents, traces, and memories are stored before committing to a provider.
Observability and evaluation
Agent debugging requires more than application logs. You need a trace that connects the user request to model calls, retrieved context, tool decisions, outputs, retries, and final business results.
LangSmith offers tracing and evaluation workflows for LangChain-based systems and can help teams inspect complex runs. AgentOps focuses on agent-specific telemetry, including tool usage, failures, latency, and cost. OpenTelemetry-compatible instrumentation is also worth adopting if your organisation already has a central observability platform.
For testing, Promptfoo supports repeatable prompt and model comparisons. Combine it with task-level tests that measure:
- Whether the correct tool was selected.
- Whether arguments were valid and complete.
- Whether the answer was grounded in approved sources.
- Whether the agent stopped within its budget and iteration limit.
- Whether unsafe, unauthorised, or ambiguous requests were escalated.
Use a fixed evaluation set plus fresh production examples. Track p50 and p95 latency, cost per successful task, tool error rate, human takeover rate, and completion quality. A cheaper model that requires frequent retries may cost more than a stronger model that finishes reliably.
A practical stack for Indian teams
A sensible starting stack for a production MVP is:
- Model layer: choose a hosted or self-hosted model based on latency, language coverage, privacy, and tool-calling quality.
- Orchestration: LangGraph for explicit workflows, or PydanticAI for typed, smaller applications.
- Tools: a small internal tool registry with schemas, permissions, timeouts, and audit events.
- Sandbox: E2B or an isolated execution service for untrusted code and file processing.
- Data: Postgres for business state, object storage for files, and a vector store only where retrieval is needed.
- Observability: traces, structured logs, cost metrics, and prompt/version tracking from the first pilot.
- Evaluation: Promptfoo or an equivalent harness with domain-specific golden cases.
For local-language products, test Hindi and other relevant Indian languages separately. Measure transcription errors, code-switching, transliteration, names, addresses, and regional vocabulary rather than assuming English benchmarks transfer. Teams building customer-facing voice systems can also review The Future of Voice Agents in Customer Service.
How to choose without overbuilding
Choose tools according to workflow risk, not popularity:
1. Single-step automation: use a model, typed tools, structured outputs, and basic logging.
2. Retrieval-based assistant: add permission-aware retrieval, citations, and groundedness tests.
3. Long-running workflow: use durable orchestration, checkpoints, retries, and human approval.
4. Multi-agent system: introduce role separation only when one agent cannot meet quality or permission requirements.
5. Code or browser agent: isolate execution, restrict network access, and test prompt-injection paths.
Before launch, define what the agent is allowed to do, what it must never do, and when it must ask for help. A narrow agent with measurable outcomes will outperform a broadly capable demo that cannot be audited.
FAQ
What is the best framework for building agents?
There is no universal winner. LangGraph is strong for stateful workflows, CrewAI for role-based collaboration, and PydanticAI for typed, validated applications. Select based on control, integration needs, and operational risk.
Do agents always need a vector database?
No. Use one when semantic retrieval over a document collection is required. Structured databases, search indexes, APIs, or a small curated context may be better for other tasks.
How should I secure an agent that can execute code?
Run code in an isolated sandbox, use ephemeral credentials and storage, restrict outbound network access, enforce CPU and memory limits, scan files, and log every execution. Never expose production secrets to the runtime.
How do I estimate agent cost?
Measure successful task cost, not just model-token price. Include retries, tool calls, retrieval, sandbox usage, storage, observability, and human review. Set per-run budgets and stop conditions early.
Should I build agents with open-source models?
Open-source models can improve control, privacy, and predictable infrastructure costs, but hosting and evaluation become your responsibility. Benchmark tool use, multilingual quality, latency, and reliability on your own tasks before switching.
Build with support from AI Grants India
If you are building an agent for Indian healthcare, fintech, commerce, public services, or enterprise operations, AI Grants India can help you move from prototype to a defensible production system. Apply to AI Grants India with a clear problem statement, target users, evaluation plan, and deployment requirements.