AI Agent Workflows: Integrating LangChain and Semantic Kernel (2026)
Category: AI Agents & Autonomous Systems
Introduction
We've compared LangGraph and Semantic Kernel as frameworks. But in the real world, large enterprises often end up using both. A Python data science team might use LangChain for RAG, while the .NET backend team uses Semantic Kernel for application logic.
This article explores Hybrid Agent Workflows—how to design systems where LangChain agents and Semantic Kernel agents collaborate, share state, and solve complex problems together.
The Integration Challenge
Why mix them?
- Library Availability: Python (LangChain) has better libraries for Data Science (Pandas, NumPy). C# (Semantic Kernel) has better integration with enterprise ERPs and active directory.
- Legacy Code: You might have an existing RAG pipeline in LangChain but a new C# web API.
- Team Skills: Let the Python team write Python, and the C# team write C#.
The simplest way to integrate is to expose one agent as a Tool for the other.
Scenario
A Semantic Kernel (SK) agent needs to analyze a CSV file. It doesn't have good data tools. It calls a LangChain agent exposed as a REST API.
Workflow
- User: "Analyze the sales trends in
data.csv."
- SK Agent: Recognizes it needs data analysis. Calls the
DataAnalysisPlugin.
- DataAnalysisPlugin: Makes an HTTP POST to
http://python-service/analyze.
- LangChain Agent: Receives the request. Uses
PandasDataFrameAgent to analyze the CSV. Returns "Sales up 20%."
- SK Agent: Receives the JSON response. Formats it for the user.
Code Snippet (Semantic Kernel Plugin)
[KernelFunction, Description("Analyzes data using the Python Data Service")]
public async Task<string> AnalyzeDataAsync(string query, string fileUrl)
{
var client = new HttpClient();
var response = await client.PostAsJsonAsync("http://python-service/analyze", new { query, fileUrl });
return await response.Content.ReadAsStringAsync();
}
Integration Pattern 2: Shared Memory (Vector DB)
Agents need to share context. If the LangChain agent learns that "Project X is delayed," the SK agent should know that too.
The Architecture
- Central Brain: A shared Vector Database (e.g., Pinecone, Qdrant).
- Protocol: Both frameworks write memories to the same collection with a standardized schema.
Workflow
- LangChain Agent: Processes a PDF. Embeds chunks. Saves to
corporate-knowledge index.
- SK Agent: User asks, "What is the status of Project X?"
- SK Memory: Performs a semantic search on
corporate-knowledge index.
- Result: Retrives the chunks saved by LangChain.
Integration Pattern 3: The "Supervisor" Pattern
For complex tasks, use a lightweight "Router" or "Supervisor" to dispatch tasks.
Architecture
- Supervisor: A fast LLM (e.g., GPT-4o-mini) that classifies intent.
- Workers: Specialized agents (LangChain for Research, SK for Business Logic).
Example
User: "Research the competitor's pricing and update our SQL database."
- Supervisor: Break this down.
- Task A: "Research pricing" -> Route to LangChain Web Search Agent.
- Task B: "Update SQL" -> Route to Semantic Kernel SQL Agent.
- Execution:
- LangChain agent scrapes web, returns JSON:
{ "competitor_price": 99 }.
- Supervisor passes this data to SK agent.
- SK agent runs
UPDATE Products SET Price = ....
Standardization: The Agent Protocol
In 2026, the Agent Protocol (an open standard) allows agents to communicate regardless of framework. It defines standard endpoints like /agent/tasks, /agent/steps, and /agent/artifacts.
- LangGraph can expose an Agent Protocol compliant endpoint.
- Semantic Kernel can consume that endpoint as a generic "Agent Plugin."
Conclusion
Monolithic agent frameworks are disappearing. The future is Composable AI, where specialized agents built in the best language for the job collaborate over standard APIs. Whether you use LangChain, Semantic Kernel, or both, the key is defining clear Interfaces and Shared State.
Don't let framework wars limit your architecture. Use the right tool (and the right agent) for the job.
