LangGraph · PiniShv

Build Your First AI Agent This Week: A Practical Guide

Fri, 03 Oct 2025 00:00:00 +0000

In my previous article, I covered what makes AI agents different and which platforms are worth using. Now it’s time to actually build one.

This isn’t theory. This is the practical path to shipping your first useful agent in seven days. Real steps, real code patterns, real deployment.

Day 1: Pick a problem that won’t waste your time
#

The most common mistake is picking the wrong first problem. Too ambitious, too vague, or too risky. You want something that teaches you how agents work without creating a disaster if it fails.

The criteria that matter:

Repetitive and annoying. Something you or your team does regularly and wish you didn’t. The kind of task where you know you’ll use the agent because the manual version is painful.

Multi-step with clear logic. It needs to check multiple sources or make decisions based on what it finds. Otherwise, you don’t need an agent, you need a function.

Low stakes. Mistakes are annoying but not catastrophic. No customer-facing systems, no data deletion, no money movement.

Well-defined success. You can describe what “done” looks like in concrete terms. Vague goals produce vague agents.

Good first problems:

Weekly engineering status report. Query your project management tool for completed tickets, check Git for merged PRs, pull highlights from meeting notes, and generate a summary. Multiple data sources, clear output format, low risk.

Pull request pre-review. Check new PRs for common issues before human review: missing tests, documentation gaps, security patterns, code style. Clear checks, actionable output, saves reviewer time.

Production health check. Monitor key metrics across your services, check error rates and latency, identify anomalies, and escalate only when thresholds are crossed. Defined logic, measurable impact.

Support ticket triage. Read incoming tickets, categorize by type, check for similar past issues, route to the right team, and flag urgent cases. Clear workflow, easy to validate.

Bad first problems:

Autonomous customer support. Too high stakes. Customers see the output directly. Requires judgment and empathy that agents don’t have.

Writing production code without review. You’re trusting an agent with your system’s reliability before you understand how agents fail. That’s backwards.

Making architectural decisions. Agents can gather information, but they can’t make taste-based trade-offs or understand your business context deeply enough.

Pick your problem now. Write down the specific task, the data sources it needs, and what the output should look like. Be concrete.

Day 2: Set up your environment and tools
#

You have two main paths: managed platforms (fast but less control) or open-source frameworks (more work, more flexibility).

Path A: OpenAI Agents SDK (fastest start)
#

When to choose this: You want to build something working today and don’t mind vendor lock-in.

Setup:

pip install openai

Create an API key from OpenAI’s platform, set it as an environment variable:

export OPENAI_API_KEY='your-key-here'

First test:

from openai import OpenAI

client = OpenAI()

# Simple function calling example
def get_ticket_count(status):
 # Your actual logic here
 return {"status": status, "count": 42}

response = client.chat.completions.create(
 model="gpt-4o",
 messages=[{"role": "user", "content": "How many open tickets?"}],
 tools=[{
 "type": "function",
 "function": {
 "name": "get_ticket_count",
 "description": "Get count of tickets by status",
 "parameters": {
 "type": "object",
 "properties": {
 "status": {"type": "string", "enum": ["open", "closed", "pending"]}
 },
 "required": ["status"]
 }
 }
 }]
)

print(response)

If that runs without errors, you’re ready.

Path B: LangGraph (maximum control)
#

When to choose this: You want to understand how agents work at a deeper level, need to avoid vendor lock-in, or have requirements that managed platforms can’t meet.

Setup:

pip install langgraph langchain-openai langsmith

You’ll still need an OpenAI API key (or use Anthropic, Gemini, or local models). Set up LangSmith for observability (free tier is fine):

export LANGCHAIN_API_KEY='your-langsmith-key'
export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_PROJECT='my-first-agent'

First test:

from langgraph.graph import StateGraph, END
from typing import TypedDict

class State(TypedDict):
 messages: list
 next_step: str

def analyze(state):
 return {"next_step": "complete"}

graph = StateGraph(State)
graph.add_node("analyze", analyze)
graph.set_entry_point("analyze")
graph.add_edge("analyze", END)

app = graph.compile()

result = app.invoke({"messages": [], "next_step": ""})
print(result)

If that runs, you’re good.

Connect to your actual data
#

Don’t build against mock data. Use real systems from day one, but safely.

Use MCP servers (covered in my MCP article) to connect to:

Your filesystem (code, documentation)
Your databases (read-only credentials on development instances)
Your Git repository
Your project management tools

Install basic MCP servers:

# Filesystem access
npm install -g @modelcontextprotocol/server-filesystem

# PostgreSQL access
npm install -g @modelcontextprotocol/server-postgres

# Git repository access
npm install -g @modelcontextprotocol/server-git

Configure them in your Claude Desktop or connect them programmatically in your agent code.

Day 3-4: Build the minimal viable agent
#

Start simple. Don’t try to handle every edge case or build the perfect architecture. Build something that works for the happy path.

Define your tools clearly
#

Each tool should do one thing well. Clear inputs, clear outputs, clear purpose.

Example: Status report agent tools

def get_completed_tickets(days=7):
 """Get tickets completed in the last N days"""
 # Query your project management API
 # Return: list of {id, title, assignee, completed_date}
 pass

def get_merged_prs(days=7):
 """Get PRs merged in the last N days"""
 # Query GitHub API or use Git MCP server
 # Return: list of {pr_number, title, author, merged_date}
 pass

def get_meeting_highlights(days=7):
 """Extract highlights from meeting notes"""
 # Read meeting notes from your docs system
 # Return: list of highlight strings
 pass

Keep them focused. One tool shouldn’t try to do everything.

Write explicit prompts
#

Tell the agent exactly what you want. Agents don’t read between the lines well.

Bad prompt:

"Generate a status report"

Good prompt:

You are a status report generator for the engineering team.
Your task:
1. Get all tickets completed in the last 7 days
2. Get all PRs merged in the last 7 days
3. Get highlights from team meetings
4. Generate a summary in this format:
## Completed This Week
- [Ticket list with assignees]
## Shipped Features
- [PR list with authors]
## Team Updates
- [Meeting highlights]
Be concise. Focus on user-visible impact.

Specificity matters enormously.

Wire it together: OpenAI example
#

from openai import OpenAI

client = OpenAI()

tools = [
 {
 "type": "function",
 "function": {
 "name": "get_completed_tickets",
 "description": "Get tickets completed in the last N days",
 "parameters": {
 "type": "object",
 "properties": {
 "days": {"type": "integer", "default": 7}
 }
 }
 }
 },
 # Define other tools similarly
]

messages = [
 {
 "role": "system",
 "content": "You are a status report generator..." # Full prompt here
 },
 {
 "role": "user",
 "content": "Generate this week's status report"
 }
]

response = client.chat.completions.create(
 model="gpt-4o",
 messages=messages,
 tools=tools
)

# Handle tool calls
while response.choices[0].finish_reason == "tool_calls":
 tool_call = response.choices[0].message.tool_calls[0]

 # Execute the requested tool
 if tool_call.function.name == "get_completed_tickets":
 result = get_completed_tickets()

 messages.append(response.choices[0].message)
 messages.append({
 "role": "tool",
 "tool_call_id": tool_call.id,
 "content": str(result)
 })

 response = client.chat.completions.create(
 model="gpt-4o",
 messages=messages,
 tools=tools
 )

print(response.choices[0].message.content)

Wire it together: LangGraph example
#

from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolExecutor
from langchain_openai import ChatOpenAI
from langchain.tools import tool

@tool
def get_completed_tickets(days: int = 7) -> list:
 """Get tickets completed in the last N days"""
 # Your implementation
 return []

tools = [get_completed_tickets]
tool_executor = ToolExecutor(tools)

class State(TypedDict):
 messages: list
 next_action: str

def call_agent(state):
 llm = ChatOpenAI(model="gpt-4o")
 llm_with_tools = llm.bind_tools(tools)
 response = llm_with_tools.invoke(state["messages"])
 return {"messages": state["messages"] + [response]}

def execute_tools(state):
 last_message = state["messages"][-1]
 tool_calls = last_message.tool_calls
 results = [tool_executor.invoke(call) for call in tool_calls]
 return {"messages": state["messages"] + results}

def should_continue(state):
 last_message = state["messages"][-1]
 if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
 return "execute_tools"
 return "end"

graph = StateGraph(State)
graph.add_node("agent", call_agent)
graph.add_node("execute_tools", execute_tools)
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue, {
 "execute_tools": "execute_tools",
 "end": END
})
graph.add_edge("execute_tools", "agent")

app = graph.compile()

Add guardrails immediately
#

Rate limits: Don’t let the agent make unlimited API calls.

import time
from functools import wraps

def rate_limit(max_calls, period):
 calls = []
 def decorator(func):
 @wraps(func)
 def wrapper(*args, **kwargs):
 now = time.time()
 calls[:] = [c for c in calls if c > now - period]
 if len(calls) >= max_calls:
 raise Exception(f"Rate limit: {max_calls} calls per {period}s")
 calls.append(now)
 return func(*args, **kwargs)
 return wrapper
 return decorator

@rate_limit(max_calls=10, period=60)
def expensive_api_call():
 pass

Read-only access: Start with read-only database credentials and API tokens. No write permissions until you’re confident.

Timeouts: Every tool should have a timeout. Agents can get stuck waiting.

from concurrent.futures import TimeoutError
import signal

def timeout(seconds):
 def decorator(func):
 def handler(signum, frame):
 raise TimeoutError()
 def wrapper(*args, **kwargs):
 signal.signal(signal.SIGALRM, handler)
 signal.alarm(seconds)
 try:
 result = func(*args, **kwargs)
 finally:
 signal.alarm(0)
 return result
 return wrapper
 return decorator

@timeout(30)
def slow_operation():
 pass

Day 5-6: Test, break, fix, iterate
#

Now use it for real work. Not a demo. Actual tasks.

Test with real scenarios
#

Run your agent on actual data from the past week. Compare its output to what you would have produced manually.

What to check:

Accuracy: Is the information correct? No hallucinated data?

Completeness: Did it find everything it should have?

Format: Is the output actually useful? Does it need reformatting?

Efficiency: How many API calls did it make? How long did it take?

Watch what it does
#

Use LangSmith (works with both OpenAI and LangGraph) to see traces of every step.

In LangSmith’s interface, you’ll see:

Every message sent to the LLM
Every tool call with parameters
Every tool response
The final output
Time and token costs for each step

Look for:

Unnecessary tool calls (calling the same thing twice)
Wrong tool choices (using the wrong tool for a task)
Poor reasoning (making bad decisions about what to do next)
Missing error handling (crashes instead of graceful failures)

Iterate on prompts and tools
#

Improve the prompt when the agent:

Makes the right tool calls but draws wrong conclusions
Doesn’t understand what you’re asking for
Produces output in the wrong format

Improve the tools when the agent:

Can’t find the information it needs
Gets errors from tool calls
Needs more granular control over what it can do

Add more guardrails when you see:

Excessive API calls
Attempts to access things it shouldn’t
Operations that take too long

Common issues and fixes
#

Issue: Agent keeps calling the same tool repeatedly

Fix: Add memory of what it’s tried. Or be more explicit in the prompt: “Call each tool exactly once, then synthesize results.”

Issue: Output format is inconsistent

Fix: Use structured output. OpenAI supports response_format with JSON schema. LangChain has structured output parsers.

Issue: Agent gives up too easily on errors

Fix: Add retry logic to tools. Return helpful error messages the agent can act on.

Issue: Too slow

Fix: Reduce model calls by better prompt design. Cache results. Use cheaper models for simple decisions.

Day 7: Package it for others to use
#

Your agent works for you. Now make it work for your team.

Turn it into a CLI tool
#

Simple wrapper for command-line use:

import argparse

def main():
 parser = argparse.ArgumentParser(description='Generate status report')
 parser.add_argument('--days', type=int, default=7, help='Days to report')
 parser.add_argument('--output', type=str, help='Output file (optional)')
 args = parser.parse_args()

 report = generate_report(days=args.days)

 if args.output:
 with open(args.output, 'w') as f:
 f.write(report)
 else:
 print(report)

if __name__ == "__main__":
 main()

Now anyone can run: python agent.py --days 7 --output report.md

Or turn it into an API
#

from fastapi import FastAPI

app = FastAPI()

@app.post("/generate-report")
async def generate_report_endpoint(days: int = 7):
 report = generate_report(days=days)
 return {"report": report}

Deploy with: uvicorn agent:app --host 0.0.0.0 --port 8000

Document how to use it
#

Write a README that covers:

What it does (specific description)

When to use it (and when not to)

How to run it (exact commands)

What it needs (API keys, permissions, data access)

What to do if it fails (common errors and fixes)

How to improve it (where to file issues or make changes)

Add observability for team use
#

Connect to LangSmith or another observability platform so you can see:

Who’s using it
Success rate
Common errors
Cost per run

This tells you if it’s actually providing value or if people hit problems.

Patterns that work
#

After building several agents, certain patterns consistently work better than others.

Pattern: Small focused agents with clear hand-offs
#

Don’t build one agent that does everything. Build multiple small agents, each with a specific job, that hand off to each other explicitly.

Example: Instead of a single “incident response agent,” build:

Detection agent: Monitors metrics and logs, identifies anomalies
Triage agent: Categorizes incidents, determines severity
Diagnosis agent: Analyzes logs and code, identifies root cause
Communication agent: Updates status page, notifies team

Each agent has clear inputs and outputs. The orchestration layer coordinates hand-offs.

Why this works:

Easier to debug (small surface area)
Easier to test (focused scope)
Easier to improve (change one without affecting others)
Easier to understand (clear responsibilities)

Pattern: Human-in-the-loop for consequential actions
#

Agents should recommend, not execute, anything with real consequences.

For actions that:

Change production systems
Spend money
Contact customers
Modify data

Show the plan first. Get approval. Then act.

Implementation:

def execute_with_approval(action, description):
 print(f"Agent wants to: {description}")
 print(f"Command: {action}")
 approval = input("Approve? (yes/no): ")

 if approval.lower() == 'yes':
 return execute(action)
 else:
 return {"status": "cancelled", "reason": "User rejected"}

Or for async workflows, write the proposed action to a queue and wait for approval before executing.

Pattern: Explicit memory and state
#

Stateless agents repeat mistakes. Give them memory so they learn from experience.

What to remember:

Past conversations and context
What worked and what failed
User preferences and corrections
Domain-specific knowledge learned over time

Simple implementation:

class AgentMemory:
 def __init__(self):
 self.conversation_history = []
 self.learned_patterns = {}

 def remember_interaction(self, input, output, feedback):
 self.conversation_history.append({
 "input": input,
 "output": output,
 "feedback": feedback,
 "timestamp": time.time()
 })

 def get_relevant_history(self, current_input):
 # Return similar past interactions
 pass

Use vector databases (Pinecone, Weaviate, Chroma) for semantic search over past interactions.

Traps that waste time
#

Trap: Building without understanding the workflow
#

Don’t automate what you don’t understand. If the manual process is unclear, the automated version will be worse.

Before building, document:

What exactly happens at each step
What decisions get made and why
What exceptions occur and how they’re handled
What the output should look like

Then build the agent.

Trap: No guardrails until something breaks
#

Every agent needs boundaries. Define them before you need them.

Minimum guardrails:

Rate limits on expensive operations
Timeouts on all tools
Read-only access by default
Explicit approval for risky actions
Input validation on all tool parameters

Trap: Ignoring observability
#

You can’t improve what you can’t see. Instrument from day one.

At minimum, log:

Every agent invocation
Every tool call with parameters and results
Every error with context
Final output and user feedback

Use LangSmith, Arize Phoenix, or W&B Weave. The free tiers are sufficient for starting out.

Trap: Optimizing too early
#

Your first version should work, not be perfect. Get it running, use it for real work, then optimize based on actual bottlenecks.

Don’t spend time on:

Complex caching before you know what’s slow
Multi-agent orchestration before single-agent works
Advanced error handling before you know what errors occur

Do spend time on:

Clear problem definition
Simple working implementation
Basic guardrails
Real usage and feedback

The 90-day rollout plan
#

You’ve built an agent that works for you. Now scale it to your team.

Weeks 1-2: Pilot with willing participants
#

Pick 2-3 people who:

Have the same pain point your agent solves
Are willing to give feedback
Won’t be upset if it fails occasionally

Have them use it for real work but with oversight. Check outputs before they’re used in important contexts.

Gather feedback systematically:

What worked well?
What produced wrong results?
What was confusing?
What took too long?
What would make them use it more?

Weeks 3-6: Refine based on reality
#

Fix the issues that came up in the pilot:

Accuracy problems: Improve prompts, add better tools, fix data quality issues.

Usability problems: Better documentation, clearer error messages, simpler interface.

Performance problems: Reduce latency, cache results, optimize tool calls.

Coverage problems: Handle edge cases that came up, add missing functionality.

Track metrics:

Success rate (tasks completed correctly)
Usage frequency (how often people actually use it)
Time saved (measured, not guessed)
User satisfaction (ask directly)

Weeks 7-10: Expand to more users
#

Open it up to the broader team, but with good documentation and support.

What people need to start:

Clear explanation of what it does
Exact setup instructions
Example usage for common cases
Who to ask when it breaks
How to give feedback

Set expectations:

What it’s good at
What it’s not good at
When to trust the output
When to double-check manually

Weeks 11-12: Measure and decide
#

Look at actual data:

Usage: Are people using it voluntarily? How often?

Value: Time saved, quality of output, impact on workflow.

Cost: API expenses, maintenance time, support burden.

Sustainability: Can you maintain this? Does it keep working as things change?

Decision time:

If it’s working: Commit to maintaining it. Document it properly. Plan the next agent.

If it’s marginal: Figure out what would make it valuable. Fix those things or kill it.

If it’s failing: Kill it cleanly. Document why so you learn for next time.

Don’t let zombie agents accumulate. Half-working automation that people route around is worse than no automation.

What to measure
#

Focus on metrics that matter for real productivity.

Time to complete workflows: Full end-to-end time, not individual steps. This captures actual impact.

Quality of output: Accuracy, completeness, usefulness. Sample outputs regularly and compare to manual work.

Adoption rate: Percentage of team using it voluntarily after the pilot ends.

Trust level: Do people use the output directly or always double-check everything?

Cost per task: API calls, compute time, maintenance effort.

Failure modes: What breaks? How often? How bad are the failures?

What’s next
#

You’ve built one agent. That’s the hard part. The second one is easier. The third one is easier still.

Build a portfolio of focused agents:

Each solving a specific problem. Each well-understood and properly bounded. Each delivering clear value.

The compounding effect is real: agents that handle routine work free you for higher-leverage problems. Which lets you build better agents. Which free up more time.

Key principles to keep:

Start with clear, specific problems
Build focused agents with explicit boundaries
Add guardrails and observability from day one
Test with real work, not demos
Measure actual value, not vanity metrics
Iterate based on usage, not assumptions
Kill what doesn’t work

The teams pulling ahead aren’t the ones with the most sophisticated agents. They’re the ones who started building simple agents months ago and never stopped learning.

Your first agent doesn’t need to be impressive. It needs to be useful. Pick a problem that annoys you, build something that solves it, and use it until it works reliably.

Then build the next one.

Resources:

LangGraph tutorials for step-by-step guidance
OpenAI Agents examples for practical patterns
LangSmith for observability and debugging
MCP servers to connect to your data
NVIDIA NeMo Guardrails for safety controls

The gap between reading about agents and building them is execution. Start today.

AI Agents for Real Productivity: What Works in 2025

Thu, 02 Oct 2025 00:00:00 +0000

The promise of AI agents is everywhere: autonomous assistants that handle your busywork, orchestrate complex workflows, and give you back hours of your day. The reality is messier.

Most AI agent demos look impressive until you try to use them for actual work. They either do too little (fancy chatbots with extra steps) or try to do too much (autonomous chaos that breaks things in creative ways).

But between the hype and the disappointment, there’s a middle ground that actually works. AI agents you build yourself, focused on specific problems, constrained by proper guardrails, and integrated into your real workflow.

This isn’t about building the next big AI product. This is about understanding what actually works so you can make smart decisions about where to invest time and resources.

What makes an agent different from a chatbot
#

The terminology is confusing because vendors use “agent” to describe everything from glorified autocomplete to autonomous systems that make irreversible decisions.

Here’s the practical distinction that matters:

A chatbot responds. You ask a question, it answers. The conversation ends. If you want something different, you ask again.

An agent decides and acts. You give it a goal, and it figures out the steps: what information it needs, what tools to use, what order to execute things in. It makes decisions dynamically based on what it learns along the way.

The key difference is agency: the ability to use tools, make decisions, and adapt based on results.

Example: You tell a chatbot “check if our API is healthy.” It might tell you how to check. An agent would actually call your monitoring API, parse the results, identify any issues, check the error logs for those specific issues, and give you a diagnosis.

That’s powerful. It’s also where things get dangerous if you build without thinking through the consequences.

Where agents actually help (and where they don’t)
#

After months of experimenting with agents for real work, I’ve seen clear patterns emerge about what succeeds and what fails.

Agents work well for:

Repetitive information gathering across multiple systems. The kind of task where you need to check five different places, correlate the data, and synthesize an answer. Agents excel at this because they don’t get bored and they’re consistent.

Example: “Analyze the last production incident - check the error logs, look at the related code changes, find similar past incidents, and summarize what happened and why.” That’s four different data sources (logs, Git, incident database, codebase) that need to be queried and connected. An agent handles it in one shot.

Workflow orchestration with clear decision points. Tasks with branching logic that depends on results. If X happens, do Y. If not, do Z. Agents can follow these flows without you manually steering each step.

Example: A code review assistant that checks style, runs security scans, looks for common anti-patterns specific to your codebase, and only escalates to human review if it finds something it can’t handle. The logic is clear, the boundaries are defined.

Data analysis and reporting. When you need to query data, transform it, apply business logic, and generate insights. As long as the queries are read-only and the logic is sound, agents can do this repeatedly without fatigue or errors.

Example: Weekly customer health reports that pull data from your database, your support system, and your usage analytics, then generate a summary with trend analysis and flagged accounts. That’s several hours of manual work that an agent can do in minutes.

Agents struggle with:

Ambiguous goals without clear success criteria. If you can’t define what “done” looks like in concrete terms, the agent will wander. Agents need specific targets.

High-stakes decisions without human oversight. Letting an agent autonomously make decisions that cost money, delete data, or affect customers is asking for trouble. Always put humans in the loop for irreversible actions.

Creative work that requires taste and judgment. Agents can generate options, but they can’t tell you which design feels right, which message resonates with your audience, or which technical trade-off aligns with your product strategy. That’s still your job.

Novel problems they haven’t seen before. Agents work best within known patterns. When they encounter something truly new, they guess, and those guesses can be confidently wrong.

The agent landscape in 2025: what’s actually worth using
#

The market has exploded with agent platforms, frameworks, and tools. Some are genuinely useful. Many are solutions looking for problems. Here’s what matters for builders.

Cloud platforms: fast to start, limited control
#

OpenAI Agents SDK (GitHub) is the easiest path to a working agent if you’re already in the OpenAI ecosystem. The Responses API handles multi-step workflows, and the Agents SDK adds tool calling, file handling, and web search. You can connect it to your systems through MCP (Model Context Protocol).

What’s good: Fast iteration. Strong model quality. Built-in safety controls. Web search and computer use features that let agents interact with browser interfaces.

What’s limited: You’re locked into OpenAI’s infrastructure. Cost control requires discipline. Less flexibility than open-source approaches.

When to use it: Rapid prototyping, proof of concepts, or production systems where convenience matters more than control.

Microsoft’s agent stack spans multiple products: (Azure AI Foundry Agent Service) for managed runtime, (Copilot Studio) for low-code multi-agent orchestration, and Semantic Kernel (GitHub) for custom development.

What’s good: Deep integration with Microsoft 365 and Azure. Enterprise governance and security built in. Computer use for automating legacy systems without APIs.

What’s limited: Complex product surface area. Licensing can get expensive. Best fit if you’re already Microsoft-heavy.

When to use it: You’re a Microsoft shop and need agents integrated with Teams, Office, or Azure services.

AWS Bedrock Agents (docs) with Guardrails for safety, plus the open-source Strands orchestration framework for multi-agent coordination.

What’s good: Scales naturally with AWS infrastructure. Strong security posture. Guardrails for Bedrock give you programmable safety controls.

What’s limited: Setup complexity is higher than other platforms. Service-specific features create lock-in.

When to use it: You’re AWS-first and want agents that integrate tightly with your existing cloud stack.

Google Vertex AI Agent Builder (docs) includes the Agent Development Kit (ADK), Agent Engine for managed runtime, and Memory Bank for stateful conversations.

What’s good: Built-in tools for code execution, search, and data access. Agent-to-agent (A2A) protocol for complex orchestrations. Strong if you’re GCP-native.

What’s limited: Newer than competitors, so some features are still in preview. Best value comes from using it with other Google Cloud services.

When to use it: You’re on GCP and need agents that work naturally with BigQuery, Cloud Storage, and other Google services.

Salesforce Agentforce (announcement) is purpose-built for customer-facing workflows. If your work lives in Salesforce CRM, Sales, or Service Cloud, Agentforce gives you pre-built templates and deep integration.

What’s good: Fast deployment for GTM and customer service use cases. Native to the Salesforce ecosystem. API and mobile SDK for custom development.

What’s limited: Best value comes from using it within Salesforce. Less general-purpose than other platforms.

When to use it: You’re a Salesforce shop and need agents for customer operations, sales workflows, or service automation.

Databricks Agent Bricks (docs) is optimized for data and analytics teams. It’s tightly integrated with Unity Catalog, MLflow, and the lakehouse architecture.

What’s good: Natural fit for data-centric agents. Strong evaluation and serving infrastructure. Enterprise governance built in.

What’s limited: Best suited for organizations already on Databricks. Less general-purpose than other frameworks.

When to use it: You’re building data or analytics agents on a lakehouse architecture.

Open-source frameworks: maximum flexibility, you run the infrastructure
#

LangGraph (GitHub) is the current leader in open-source agent orchestration. It’s built on LangChain but designed specifically for stateful, graph-based agent workflows.

What’s good: True control over behavior. Graph-based execution lets you see and debug agent reasoning. Built-in persistence, retries, and human-in-the-loop patterns. Huge ecosystem of integrations. Works with any LLM.

What’s limited: You manage the infrastructure. Steeper learning curve than managed platforms. You’re responsible for safety and guardrails.

When to use it: You need maximum flexibility, want to avoid vendor lock-in, or have requirements that managed platforms can’t meet.

LlamaIndex (GitHub) focuses on data-centric agents. If your agent needs to work with documents, databases, and complex data sources, LlamaIndex has the deepest RAG (retrieval-augmented generation) tooling.

What’s good: Excellent data connectors. AgentWorkflows for multi-agent patterns. Strong at combining structured and unstructured data.

What’s limited: Narrower focus than general-purpose frameworks. Best suited for data and knowledge work.

When to use it: Your agents primarily work with documents, databases, and knowledge bases.

CrewAI (GitHub) is opinionated about multi-agent teams. You define roles, assign skills, and CrewAI orchestrates collaboration between agents.

What’s good: Simple mental model. Fast growing community. Good for scenarios where you want specialized agents working together.

What’s limited: Less low-level control than LangGraph. Opinionated design means you work within its patterns.

When to use it: You want team-of-agents patterns without building orchestration from scratch.

Haystack (GitHub) from deepset is production-grade RAG plus agents. It’s mature, well-documented, and has clear patterns for evaluation and deployment.

What’s good: Battle-tested in production. Pipeline model is easy to reason about. Good observability and eval integration.

What’s limited: Less flexible than LangGraph for complex agent behaviors. Optimized for RAG-heavy workflows.

When to use it: You need production-ready RAG with agent capabilities, and you value stability over cutting-edge features.

Safety and observability: the unsexy stuff that matters
#

NVIDIA NeMo Guardrails (GitHub) is the most programmable safety layer. It works across different stacks and lets you define explicit policies for what agents can and can’t do.

Why this matters: Agents without guardrails will eventually do something you didn’t intend. NeMo lets you prevent that proactively with code, not hope.

LangSmith (site), Arize Phoenix (GitHub), and Weights & Biases Weave (docs) give you observability into what your agents are actually doing. Trace every step, see every tool call, measure quality and cost.

Why this matters: Agents are black boxes without instrumentation. When something goes wrong (and it will), you need to see exactly what happened. When costs spike, you need to know why.

Making the right choice for your situation
#

The landscape is crowded, but the decision framework is straightforward.

If you’re already invested in a cloud ecosystem:

Go with your cloud provider’s agent platform. The integration is easier, the security model aligns with your existing setup, and you leverage investments you’ve already made.

Microsoft 365/Azure heavy → Microsoft’s agent stack
AWS infrastructure → Bedrock Agents with Guardrails
GCP and BigQuery → Vertex AI Agent Builder
Salesforce for GTM → Agentforce
Databricks lakehouse → Agent Bricks

If you need maximum flexibility and control:

Start with LangGraph. It’s the most mature open-source orchestration framework with the largest ecosystem. Add LlamaIndex for data-intensive work, NeMo Guardrails for safety, and LangSmith for observability.

If you want to move fast with minimal setup:

OpenAI Agents SDK gets you running quickest. Strong defaults, good documentation, integrated tools. Accept the vendor lock-in as the trade-off for speed.

If you’re in a regulated industry or have strict compliance needs:

Microsoft’s agent stack or AWS Bedrock give you the enterprise controls and audit trails you’ll need. NVIDIA NeMo Guardrails works across platforms if you need programmable safety.

What matters more than the platform
#

The platform choice matters less than these fundamentals:

Clear problem definition. Vague goals produce vague results. Agents need specific, measurable success criteria.

Proper guardrails from day one. Safety isn’t something you add later. Build it in from the start.

Observability and measurement. You can’t improve what you can’t see. Instrument everything.

Realistic expectations. Agents augment human judgment, they don’t replace it. The best results come from thoughtful human-agent collaboration.

Iterative refinement. Your first agent won’t be great. That’s fine. Build, test, learn, improve.

For engineering leaders: the strategic opportunity
#

If you lead a team or organization, AI agents represent more than a productivity tool. They’re a forcing function for operational clarity.

The immediate play: Teams with well-designed agents handle more work with the same headcount, or maintain output with less burnout. The productivity gains are real and measurable.

The deeper value: Building agents forces you to clarify processes, document decisions, and standardize workflows. That organizational clarity compounds beyond just the agents themselves.

The investment thesis: Start small with focused agents solving specific problems. Build expertise through real use. Expand as you learn what works in your specific context.

The approach that works: Don’t mandate top-down. Let teams build agents for their own pain points. Provide infrastructure, guidelines, and shared learnings. The best agents emerge from people solving their own problems.

The risks to watch: Agents without guardrails. Agents without observability. Agents that automate broken processes. Teams that become dependent without understanding the underlying work.

The goal: Leveraged productivity, not maximum automation. Free your team from repetitive cognitive work so they can focus on problems requiring judgment, creativity, and expertise.

For developers: why this matters to your career
#

Building agents isn’t specialist knowledge. It’s becoming table stakes for productive developers.

The skill combination that’s valuable: Understanding both AI capabilities and production systems. How to give AI the right context without compromising security. How to design integrations that teams actually use.

What’s valuable right now:

Using existing agent frameworks effectively
Building focused agents for specific workflows
Implementing proper security and guardrails
Designing integrations that scale

What becomes more valuable:

Deep expertise in agent orchestration patterns
Domain-specific integration knowledge
Platform-level thinking about AI-system connections
Security and compliance for AI integrations

The trajectory: Developers who can build reliable agents that solve real problems are differentiating themselves. Not because it’s exotic, but because it’s practical infrastructure work that delivers measurable value.

What separates success from expensive failure
#

Most AI agent projects fail. Not because the technology isn’t ready, but because teams skip fundamentals.

They build before understanding the problem. They automate before adding guardrails. They deploy before instrumenting. They scale before validating.

The agents that work share common traits:

Focused on specific, well-defined problems
Built with clear boundaries and safety controls
Instrumented from day one with proper observability
Validated with real use before broad deployment
Maintained and improved based on actual usage patterns

The discipline required is higher than traditional development. Agents make autonomous decisions. Mistakes compound. Poor judgment scales. You need to be more thoughtful, not less.

But when done right, the leverage is real. Work that took hours happens in minutes. Repetitive cognitive tasks disappear. Context gathering becomes automatic. Teams handle more complexity with less stress.

Where to start
#

Understanding the landscape is step one. Building something real is step two.

In my next article, I’ll walk through the practical steps: picking the right first problem, setting up your tools, building a working agent in a week, and deploying it to your team. The tactical guide to actually shipping.

For now, the strategic takeaway is clear: AI agents work when they’re focused, bounded, and built for specific workflows. The platform matters less than the approach.

The teams winning with agents aren’t the ones with the best strategy. They’re the ones who started experimenting months ago and never stopped learning.

Start small. Build focused. Measure ruthlessly. The productivity gains compound faster than you’d expect.

Key resources:

LangGraph documentation for open-source agent orchestration
OpenAI Agents SDK for managed agent development
Microsoft Semantic Kernel for multi-language agent development
NVIDIA NeMo Guardrails for cross-platform safety controls
LangSmith for agent observability and debugging

The gap between AI agent demos and actual productivity is understanding what works and what doesn’t. Then building accordingly.

LangGraph · PiniShv

Build Your First AI Agent This Week: A Practical Guide

Day 1: Pick a problem that won’t waste your time #

Day 2: Set up your environment and tools #

Path A: OpenAI Agents SDK (fastest start) #

Path B: LangGraph (maximum control) #

Connect to your actual data #

Day 3-4: Build the minimal viable agent #

Define your tools clearly #

Write explicit prompts #

Wire it together: OpenAI example #

Wire it together: LangGraph example #

Add guardrails immediately #

Day 5-6: Test, break, fix, iterate #

Test with real scenarios #

Watch what it does #

Iterate on prompts and tools #

Common issues and fixes #

Day 7: Package it for others to use #

Turn it into a CLI tool #

Or turn it into an API #

Document how to use it #

Add observability for team use #

Patterns that work #

Pattern: Small focused agents with clear hand-offs #

Pattern: Human-in-the-loop for consequential actions #

Pattern: Explicit memory and state #

Traps that waste time #

Trap: Building without understanding the workflow #

Trap: No guardrails until something breaks #

Trap: Ignoring observability #

Trap: Optimizing too early #

The 90-day rollout plan #

Weeks 1-2: Pilot with willing participants #

Weeks 3-6: Refine based on reality #

Weeks 7-10: Expand to more users #

Weeks 11-12: Measure and decide #

What to measure #

What’s next #