Building AI Agents for Development: LangGraph vs Semantic Kernel (2026)
Category: AI Agents & Autonomous Systems
Introduction
In 2026, the software industry has moved beyond "chatbots" to Autonomous AI Agents. These are not just LLMs that answer questions; they are systems that perceive their environment, reason about tasks, and act to achieve goals. From fixing bugs in a CI pipeline to scaffolding entire microservices, agents are the new workforce.
Building these agents requires robust frameworks. Two giants have emerged as the standards: LangGraph (by LangChain) and Semantic Kernel (by Microsoft). This article provides a practical guide to building development agents using these frameworks.
For a broader look at the infrastructure powering these agents, check out AI Agents Infrastructure.
Understanding AI Agents
An AI agent is an LLM equipped with:
- Tools: Functions it can call (e.g.,
readFile(), runTest(), gitCommit()).
- Memory: Short-term (conversation history) and long-term (vector DB) context.
- Planning: A loop that decides "What tool should I use next?" based on the current state.
The Loop
- Observe: Read user goal ("Fix the failing test").
- Think: "I need to run the test to see the error."
- Act: Call
runTest().
- Observe: "Error:
Expected 200, got 500."
- Think: "I need to read the controller code."
- Act: Call
readFile('controller.ts').
...and so on until the goal is met.
LangGraph: State as a Graph
LangChain started as a chain of calls. LangGraph evolved this by modeling agent workflows as a State Machine (Graph). This is crucial for loops and cycles, which are inherent in agentic behavior.
Core Concepts
- State: A shared dictionary (e.g.,
{ messages: [], errors: [] }) passed between nodes.
- Nodes: Functions that do work (e.g., "Call LLM", "Execute Tool").
- Edges: Logic that decides where to go next (e.g., "If tool called, go to ToolNode; else go to End").
Code Example: A Simple Coding Agent
Here is how you build an agent that can write files using LangGraph (Python).
from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, List
from langchain_core.messages import HumanMessage, AIMessage
# 1. Define State
class AgentState(TypedDict):
messages: List[str]
code: str
# 2. Define Nodes
def reasoner(state: AgentState):
# Call LLM to decide what to do
response = llm.invoke(state['messages'])
return {"messages": [response]}
def coder(state: AgentState):
# Simulate writing code
return {"code": "print('Hello World')"}
# 3. Build Graph
workflow = StateGraph(AgentState)
workflow.add_node("reasoner", reasoner)
workflow.add_node("coder", coder)
workflow.set_entry_point("reasoner")
workflow.add_edge("reasoner", "coder")
workflow.add_edge("coder", END)
app = workflow.compile()
# 4. Run
app.invoke({"messages": [HumanMessage(content="Write a python script")]})
Pros and Cons
- Pros: Extremely flexible, great for complex cyclical logic (loops), native integration with the massive LangChain ecosystem.
- Cons: Can be verbose; debugging graph states can be tricky without visualization tools.
Semantic Kernel: The Enterprise Choice
Semantic Kernel (SK) is Microsoft's open-source SDK. It is designed to be lightweight and easily embeddable into existing applications (C#, Python, Java). It treats AI services as "Plugins."
Core Concepts
- Kernel: The central orchestrator that manages resources.
- Plugins: Collections of functions (native code or AI prompts) that the kernel can call.
- Planners: Specialized modules that automatically stitch plugins together to solve a user request.
Code Example: A Planner Agent
Here is how you use a Planner in Semantic Kernel (C#) to automatically chain steps.
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Planning;
// 1. Initialize Kernel
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion("gpt-4", endpoint, key);
var kernel = builder.Build();
// 2. Import Plugins (Tools)
kernel.ImportPluginFromType<FilePlugin>("FilePlugin");
kernel.ImportPluginFromType<GitPlugin>("GitPlugin");
// 3. Create a Planner
var planner = new HandlebarsPlanner(new HandlebarsPlannerOptions() { AllowLoops = true });
// 4. Create a Plan
string goal = "Read the README.md and create a summary file.";
var plan = await planner.CreatePlanAsync(kernel, goal);
// 5. Execute Plan
var result = await plan.InvokeAsync(kernel);
Pros and Cons
- Pros: Strong typing (C# support is first-class), "Planner" abstraction is powerful for automatic orchestration, enterprise-grade reliability.
- Cons: Python support sometimes lags behind C#; ecosystem is smaller than LangChain's.
Feature Comparison
| Feature | LangGraph | Semantic Kernel |
|---|
| Primary Language | Python / JavaScript | C# / Python / Java |
| Architecture | Graph / State Machine | Kernel + Plugins |
| Orchestration | Explicit Edges & Conditional Logic | AI-Driven "Planners" |
| Ecosystem | Massive (LangChain) | Growing (Microsoft) |
| Best For | Complex, custom research agents | Enterprise apps, .NET shops |
Building a "Code Review Agent"
Let's see how we would architect a Code Review Agent in both.
The Goal
- Read files in a Pull Request.
- Analyze code for bugs.
- Post comments on the PR.
LangGraph Approach
You would define a graph with a cycle:
FetchPR -> AnalyzeFile -> (Loop for each file) -> AggregateComments -> PostReview.
The explicit control flow allows you to handle rate limits or complex retry logic precisely at each step.
Semantic Kernel Approach
You would write plugins: GitHubPlugin (with GetFiles, PostComment) and ReviewPlugin (with AnalyzeCode).
You then ask the Planner: "Review PR #123." The Planner automatically figures out: "I need to call GetFiles first, then loop through them with AnalyzeCode, then call PostComment."
Conclusion
Which one should you choose?
- Use LangGraph if you are building a standalone AI Product (like a coding assistant) where you need granular control over the agent's cognitive architecture and state loops. It gives you the "low-level" primitives of cognition.
- Use Semantic Kernel if you are adding AI features to an existing enterprise application, especially if you are in the Microsoft stack. Its Plugin architecture makes it safe and easy to expose your existing business logic to the AI.
In 2026, the question isn't "if" you will build agents, but "how." These frameworks provide the scaffolding so you can focus on the intelligence.
