> ## Documentation Index
> Fetch the complete documentation index at: https://docs.xpander.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# SDK integrations
> Pick an agent loop and see what xpander wires up for you
xpander supplies your agent's identity (instructions, skills, knowledge bases, memory, deployment target) and delivers each task to your handler. In the SDK, skills are exposed as `tools`, the name agent loops use for them.
Agents created in Xpander Chat or through the API run on Claude Code, Codex or OpenCode by default. The SDK integrations on these pages are optional: you pick them when you want to run the LLM loop in your own process. The **agent loop** you choose is the library that does that: the thing with an `Agent` class, a function-calling interface, and an `arun()` method. xpander does not replace your agent loop; it supplies the agent definition and runs every skill call.
Selection lives in `xpander_config.json`, written by `xpander agent new`. The SDK reads the `framework` field from that file and wires up accordingly:
```json xpander_config.json theme={"dark"}
{
"agent_id": "agt_01H...",
"organization_id": "org_01H...",
"api_key": "xpd_...",
"framework": "agno" // or: "open-ai-agents", "langchain", "strands-agents"
}
```
Right now, the SDK integrates with four agent loops:
## Comparison
| Capability | Agno | OpenAI Agents SDK | LangChain | AWS Strands |
| - | - | - | - | - |
| Pre-built skills from the catalog | Auto-included | `agent.openai_agents_sdk_tools` | `agent.tools.functions` | `agent.strands_tools` |
| Custom `@register_tool` functions | Auto-included | Auto-included | Auto-included | Auto-included |
| Instructions (role, goal, general) | Auto-attached | `agent.instructions.full` | `agent.instructions.full` | `agent.instructions.full` |
| Model + provider credentials | Auto-attached | `agent.model_name` (you build the client) | `agent.model_name` (you build the client) | `agent.model_name` (you build the client) |
| Knowledge-base retriever | Auto-attached | Manual via `agent.knowledge_bases_retriever()` | Manual | Manual |
| Session storage (Postgres) | Auto-wired | Manual | Manual | Manual |
| User and agent memory | Auto-wired | Manual | Manual | Manual |
| Context optimization (toon encoding, compaction) | Auto-wired | Not available | Not available | Not available |
| Guardrails (PII, prompt injection, moderation) | Auto-wired | Manual | Manual | Manual |
| Multi-agent teams | Auto-wired (`AgnoTeam`) | Manual | Manual | Manual |
| Session helpers (`agent.get_user_sessions`, etc.) | Yes | Raises `NotImplementedError` | Raises `NotImplementedError` | Raises `NotImplementedError` |
A few takeaways worth calling out:
* **Agno is the only path with automatic wiring.** `Backend.aget_args()` dispatches on `agent.framework`. On the other three, you load the agent through `Agents().aget(...)` and read fields off it yourself.
* **Pre-built skills and custom `@register_tool` functions reach every agent loop.** What changes is the property name you read them from: `agent.tools.functions` for LangChain, `agent.openai_agents_sdk_tools` for the OpenAI Agents SDK, `agent.strands_tools` for AWS Strands.
* **Memory, knowledge retrieval, and guardrails are Agno-only auto-wired.** On the other agent loops, xpander gives you the data (`agent.knowledge_bases_retriever()`, session metadata, the agent's memory config) but your code is responsible for plugging it into the loop.
* **Agno-exclusive features**: context optimization (toon encoding, runtime compaction), `AgnoTeam`-based multi-agent coordination, and the session helpers (`agent.get_user_sessions`, `agent.get_session`, `agent.delete_session`, which raise `NotImplementedError` outside Agno).
## How to choose
Within the SDK path, start with Agno unless you have a reason not to. Pick a non-Agno agent loop when:
* **Existing investment.** Your team already builds on it and switching cost is real. Example: a LangGraph workflow that's been in production for six months.
* **Loop-specific feature.** You need something Agno doesn't have. Example: LangGraph's stateful multi-step workflows, the OpenAI Agents SDK's `Runner` ergonomics, Strands' AWS-native primitives.
* **Embedded in an existing app.** You're adding xpander skills to a service that already runs one of these agent loops. Example: a FastAPI service that already imports `agents.Runner`.
You're not locked in. The agent's identity lives in xpander's control plane, so you can swap agent loops later by editing `framework` in `xpander_config.json` and rewriting your handler.
## Next steps
The recommended path. What `Backend.aget_args()` actually wires up.
Manual wiring with `agent.openai_agents_sdk_tools`.
Manual wiring with `agent.tools.functions` and `create_react_agent`.
Manual wiring with `agent.strands_tools` on AWS-native orchestration.
The SDK class names mapped onto agents, tasks, threads, skills, and memory.
10-minute scaffold-to-deploy walkthrough on the Agno path.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.