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:

1. Tools: Functions it can call (e.g., readFile(), runTest(), gitCommit()).
2. Memory: Short-term (conversation history) and long-term (vector DB) context.
3. Planning: A loop that decides "What tool should I use next?" based on the current state.

The Loop

1. Observe: Read user goal ("Fix the failing test").
2. Think: "I need to run the test to see the error."
3. Act: Call runTest().
4. Observe: "Error: Expected 200, got 500."
5. Think: "I need to read the controller code."
6. 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

1. Read files in a Pull Request.
2. Analyze code for bugs.
3. 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.