Comparison
aidy has one job: make an existing product agent-native from the HTTP API it already serves. The tools below each focus on something else, and several combine well with aidy. This page describes each by its focus; check their own documentation for current features.
At a glance
Section titled “At a glance”| Focus | Where tools come from | Identity and approvals | Surfaces produced | |
|---|---|---|---|---|
| LangGraph | Orchestrating stateful agents as graphs, with durable execution | Code you write (Python or JS), or MCP servers | Interrupts and checkpoints for human-in-the-loop; identity and policy are up to your graph | The agent runtime; UI and other surfaces are yours to build |
| CopilotKit | In-app copilots and agentic UI in React | Frontend actions and the backend agent you connect | Human-in-the-loop UI flows; identity is your app’s | React UI components and hooks |
| Stainless, Speakeasy | Generating SDKs and related artifacts from OpenAPI | OpenAPI | The caller supplies credentials; SDKs and MCP servers call your API as that caller | SDKs in several languages, MCP servers, and more depending on the vendor |
| Vercel AI SDK, Mastra | Model providers, streaming, tool calling, agent loops (Mastra adds workflows, memory and RAG) | Code you write, or MCP servers | Tool-level hooks and approval primitives; identity and policy are your app’s | Libraries and UI hooks for the app you build |
| aidy | Making an existing product agent-native from its API | OpenAPI operations annotated with x-aidy |
Every call runs as the signed-in user with their own credential and a signed assertion; approvals are decided by catalog policy in code and bound to the hash of the exact arguments | In-app agent (AG-UI), MCP server, CLI, skill.md, llms.txt, operation reference, federated search, knowledge answers, React components |
LangGraph
Section titled “LangGraph”LangGraph is a framework for building agents as explicit state graphs. It is good at long-running, multi-step workflows: branching, retries, durable execution with checkpoints, and pausing for a human with interrupts. You define the tools and the graph in code.
Pick it when your problem is the workflow itself: a multi-agent research pipeline, a long approval chain, a process that must survive restarts.
With aidy. aidy does not depend on LangGraph, and the two fit together through a deferred task. An x-aidy operation can start a LangGraph run and answer 202 {"aidyTask": "<id>"}. aidy pauses the user’s run, shows task progress, and resumes when your service posts the result to POST /aidy/v0/tasks/{taskId}. The user starts the workflow from the product’s agent, CLI or MCP, with the usual approval in front of it.
CopilotKit
Section titled “CopilotKit”CopilotKit provides React components and hooks for in-app copilots: chat UIs, frontend actions the agent can call, shared state and generative UI. It created the AG-UI protocol, and it connects to many agent backends through it.
Pick it when you are building a custom copilot experience in React and want rich control over the UI, frontend actions and agent state.
With aidy. aidy streams AG-UI 1.0. Its run endpoint, POST /aidy/v0/threads/{id}/runs, takes an AG-UI RunAgentInput (the thread’s messages, and resume entries for interrupts) and answers with AG-UI events, so an AG-UI client can drive aidy once it has created a thread with POST /aidy/v0/threads. aidy supplies the agent: tools derived from your API, calls as the user, and approval interrupts. aidy has not been tested with CopilotKit’s own runtime, so check approval interrupts and resume entries end to end before you rely on it. @aidy-dev/react is aidy’s own set of components (dock, approval card, form, search palette) for teams that prefer a ready-made UI.
Stainless and Speakeasy
Section titled “Stainless and Speakeasy”Stainless and Speakeasy generate high-quality SDKs from an OpenAPI document, in many languages, and keep them up to date as the API changes. Both also generate MCP servers from the same document, and offer more artifacts such as docs, CLIs or Terraform providers depending on the vendor.
Pick them when you want polished, idiomatic client libraries for your API, or an MCP server for developers who call your API directly with their own keys.
With aidy. Both start from OpenAPI, so one annotated document can feed both. The difference is focus. SDK generators produce clients that other programs run. aidy runs an agent inside your product for the signed-in user: it holds the conversation, asks the user to approve each write with the exact arguments shown, executes only those arguments, and adds search, knowledge answers and UI components. Its MCP server and CLI come from the same catalog and the same approval rules.
Vercel AI SDK and Mastra
Section titled “Vercel AI SDK and Mastra”The Vercel AI SDK is a TypeScript toolkit for model providers, streaming, structured output, tool calling and agent loops, with UI hooks for React and other frameworks. Mastra is a TypeScript agent framework built on it, adding workflows, memory, RAG and evals.
Pick them when you are building an AI feature or agent from scratch in TypeScript and want to design its tools, prompts and flow yourself.
With aidy. aidy uses the AI SDK’s provider packages internally (@ai-sdk/openai-compatible, @ai-sdk/openai, @ai-sdk/anthropic) and runs its own loop on top, so that retries, event coalescing, approvals and step accounting stay in aidy. You can keep building bespoke AI features with the AI SDK or Mastra and use aidy for the part that operates the product: the tools come from your API, and the safety rules come from the catalog. See Models.
When aidy fits
Section titled “When aidy fits”aidy fits when you already have a product with an HTTP API and an authorization model, and you want users and their agents to operate it in natural language without a second business layer:
- the tools are the operations your UI already calls;
- the agent can do exactly what the user can do, because your API authorizes every call as that user;
- writes need the user’s approval of the exact arguments, enforced in code;
- one annotation gives you the in-app agent, MCP, CLI, generated docs and search together.
If you need a general-purpose agent framework, a custom workflow engine, or client SDKs, the tools above are built for that, and aidy can sit alongside them.