A TypeScript agent runtime that enables developers to build agents with planning, multi-agent handoffs, and human-in-the-loop capabilities.
Also known as Cognipeer/agent-sdk, @cognipeer/agent-sdk
- Stars
- 7
- Tools
- —
- Downloads, 30 days
- 2,634
- Latest version
- —
- Last commit
- Nov 15, 2026
- License
- MIT
What is agent-sdk MCP?
agent-sdk is a TypeScript agent runtime that enables developers to build agents with planning, multi-agent handoffs, and human-in-the-loop capabilities.
Summary generated from the project's README
About agent-sdk MCP server
This TypeScript agent runtime provides a message-first environment for developers building autonomous agents. It is designed to handle complex workflows through planning, multi-agent handoffs, and human-in-the-loop interactions. The SDK supports a wide range of providers including OpenAI, Anthropic, Azure, AWS Bedrock, and Google Vertex AI, either through a native provider layer or via LangChain adapters. It requires Node.js 18.17 or higher to run.
Users can implement advanced logic such as adaptive planning using the manage_todo_list tool and automatic token-aware summarization to manage long conversation histories. The runtime allows for sophisticated agent composition where developers can wrap agents as tools or use delegation commands like spawn_subagent to decompose problems. For security and control, the system includes human-in-the-loop capabilities where tools can pause for user approval or use the ask_user_question tool to request structured input before resuming execution.
What you can do with it
- 1Manage complex task planningAn AI agent can maintain a structured list of tasks to ensure all steps of a plan are completed.
- 2Handle long conversation historiesThe system automatically manages token limits by summarizing old tool outputs while keeping them recoverable.
- 3Implement human oversightDevelopers can create workflows that pause and wait for a person to review a tool call or answer a question.
- 4Decompose problems with sub-agentsAn orchestrator can delegate specific parts of a request to specialized child agents.
Written from the project's README. Every use case is checked against a quote from it.
How to install agent-sdk MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall agent-sdk MCP in Claude Code
$ claude mcp add agent-sdk -- npx -y @cognipeer/agent-sdkInstall agent-sdk MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"agent-sdk": {
"command": "npx",
"args": [
"-y",
"@cognipeer/agent-sdk"
]
}
}
}Install agent-sdk MCP in VS Code
.vscode/mcp.json
{
"servers": {
"agent-sdk": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@cognipeer/agent-sdk"
]
}
}
}Install agent-sdk MCP in VS Code CLI
$ code --add-mcp '{"name":"agent-sdk","type":"stdio","command":"npx","args":["-y","@cognipeer/agent-sdk"]}'Install agent-sdk MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"agent-sdk": {
"command": "npx",
"args": [
"-y",
"@cognipeer/agent-sdk"
]
}
}
}Install agent-sdk MCP in Codex
$ codex mcp add agent-sdk -- npx -y @cognipeer/agent-sdkInstall agent-sdk MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.agent-sdk] command = "npx" args = ["-y", "@cognipeer/agent-sdk"]
Install agent-sdk MCP in Gemini CLI
$ gemini mcp add -s user agent-sdk npx -- -y @cognipeer/agent-sdkInstall agent-sdk MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"agent-sdk": {
"command": "npx",
"args": [
"-y",
"@cognipeer/agent-sdk"
]
}
}
}Configuration
OPENAI_API_KEY
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablecognipeer/agent-sdk is public and reachablegithub.com/cognipeer/agent-sdk ↗Pass
- Package names this repository as its source@cognipeer/agent-sdk names cognipeer/agent-sdk as sourcenpmjs.com/package/@cognipeer/agent-sdk ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for @cognipeer/agent-sdknpmjs.com/package/@cognipeer/agent-sdk/v/0.22.2#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-11github.com/cognipeer/agent-sdk ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from @cognipeer/agent-sdkPass
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHub@cognipeer/agent-sdk
Lightweight, message-first TypeScript agent runtime for developers who want transparent tool calls, planning and tracing.
Docs · Quick start · Examples · Changelog · Contact
Adoption: in active use at close to 20 companies that Cognipeer supports as enterprise customers. Open-source users are not included in this count.
Lightweight, message-first agent runtime that keeps tool calls transparent, supports provider-native reasoning plus post-tool reflection, automatically summarizes long histories, and ships with planning, multi-agent handoffs, and structured tracing.
- SDK source:
src/ - Examples:
examples/ - Docs (VitePress):
docs/ - Requires Node.js 18.17+
Table of contents
- Overview
- What’s inside
- Install
- Quick start
- Key capabilities
- Examples
- Architecture snapshot
- API surface
- Tracing & observability
- Development
- Troubleshooting
- Documentation
Overview
@cognipeer/agent-sdk is a zero-graph, TypeScript-first agent loop. Tool calls are persisted as messages, token pressure triggers automatic summarization, and optional planning mode enforces TODO hygiene with the bundled manage_todo_list tool. Multi-agent composition, structured output, and batched tracing are built-in.
Highlights:
- Message-first design – assistant tool calls and tool responses stay in the transcript.
- Token-aware summarization – chunked rewriting archives oversized tool outputs while exposing
get_tool_responsefor lossless retrieval. - Planning mode – adaptive system prompt + TODO tool supports full plan writes and version-safe partial updates.
- Unified reasoning surface – one
reasoningconfig controls provider-native reasoning and post-tool plain-text reflections. - Structured output – provide a Zod schema and the agent injects a finalize tool to capture JSON deterministically.
- Skills / progressive disclosure – expose cheap capability headers first, then bind skill tools on demand with
open_skillandbind_skill_tools. - Multi-agent and handoffs – wrap agents as tools or transfer control mid-run with
asTool/asHandoff. - Sub-agents / dynamic delegation – let the orchestrator decompose problems with
delegate_to(registry),spawn_subagent(ad-hoc), andspawn_subagents_parallel(fan-out); children are model-agnostic and inherit event and cancellation wiring (child text streaming is opt-in viasubagentPolicy.streamChildren). Opt-in: the spawn tools +<available_subagents>catalog appear only when you passsubagentsand/orsubagentPolicy. - Prompt overrides – intercept otherwise-static prompts with
promptHooks(transformSystemPrompt,toolDescriptions,subagentCatalog). - Human-in-the-loop –
needsApprovaltools pause for review;humanInTheLoop.askUserenables a built-inask_user_questiontool that pauses with a structured multi-choice prompt and resumes from the user's answer. - Usage + events – normalize provider usage, surface
tool_call,tool_approval,user_question,plan,summarization,reflection,metadata,handoff, andsubagentevents. - Structured tracing – optional per-invoke JSON traces with metadata, payload capture, and pluggable sinks (file, HTTP, Cognipeer, custom).
What’s inside
| Path | Description |
|---|---|
src/ |
Source for the published package (TypeScript, bundled via tsup). |
examples/ |
End-to-end scripts demonstrating tools, planning, summarization, multi-agent, MCP, structured output, and vision input. |
docs/ |
VitePress documentation site served at docs.cognipeer.com/agent-sdk. |
dist/ |
Build output (generated). Contains ESM, CommonJS, and TypeScript definitions. |
logs/ |
Generated trace sessions when tracing.enabled: true. Safe to delete. |
Install
Install the SDK. Every @langchain/* package (and langchain) is an optional peer dependency, nothing imports LangChain unless you use the LangChain adapters:
npm install @cognipeer/agent-sdk zod
# Optional: LangChain bindings (if you want to use fromLangchainModel)
npm install @langchain/core @langchain/openai
The SDK includes a built-in native provider layer that talks directly to OpenAI, Anthropic, Azure, Bedrock, Vertex, and any OpenAI-compatible API — no LangChain required.
You can also bring your own model adapter as long as it exposes invoke(messages[]) and (optionally) bindTools().
Quick start
Native provider (no LangChain)
import { createSmartAgent, createTool, createProvider, fromNativeProvider } from "@cognipeer/agent-sdk";
import { z } from "zod";
const echo = createTool({
name: "echo",
description: "Echo back user text",
schema: z.object({ text: z.string() }),
func: async ({ text }) => ({ echoed: text }),
});
// Pick any provider – OpenAI, Anthropic, Azure, Bedrock, Vertex, or OpenAI-compatible
const model = fromNativeProvider(
createProvider({ provider: "openai", apiKey: process.env.OPENAI_API_KEY! }),
{ model: "gpt-4o" },
);
const agent = createSmartAgent({ model, tools: [echo], runtimeProfile: "balanced" });
const result = await agent.invoke({ messages: [{ role: "user", content: "say hi" }] });
console.log(result.content);
Switch providers by changing a single config line:
// Anthropic
createProvider({ provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY! })
// Azure OpenAI
createProvider({ provider: "azure", apiKey: "...", endpoint: "https://my-resource.openai.azure.com", deploymentName: "gpt-4o" })
// AWS Bedrock
createProvider({ provider: "bedrock", region: "us-east-1", accessKeyId: "...", secretAccessKey: "..." }) // streams via ConverseStream
// Google Vertex AI
createProvider({ provider: "vertex", projectId: "my-project", accessToken: process.env.VERTEX_TOKEN }) // retry on 429/5xx, thoughtSignature round-trip; reasoning.thinkingLevel for Gemini 3
// Any OpenAI-compatible endpoint (Ollama, Groq, Together, vLLM, …)
createProvider({ provider: "openai-compatible", apiKey: "...", baseURL: "https://custom.endpoint/v1" })
Embeddings
Every provider with an embeddings endpoint exposes embed(). It returns one vector per input, in order, plus token usage:
const provider = createProvider({ provider: "openai", apiKey: process.env.OPENAI_API_KEY! });
const { vectors, usage } = await provider.embed({
model: "text-embedding-3-small",
input: ["first text", "second text"],
dimensions: 256, // models that support shortening
inputType: "search_query" // Cohere on Bedrock, task type on Vertex
});
| Provider | Endpoint | Notes |
|---|---|---|
openai, openai-compatible |
POST /embeddings |
batched (2048), encodingFormat: "base64" is decoded |
azure |
/openai/deployments/{model}/embeddings |
model is the deployment name |
bedrock |
InvokeModel |
Titan Text Embeddings v1/v2, Cohere Embed v3/v4 |
vertex |
:predict |
text-embedding, multilingual, gemini-embedding |
Gateway use
For hosts that front the providers with their own gateway: ChatCompletionRequest takes streamUsage, seed, n, parallelToolCalls, logprobs and topLogprobs; responses and stream chunks keep the provider's rawFinishReason and providerFields (system_fingerprint, service_tier, annotations, refusal, logprobs); streamed tool-call deltas carry an index. On Bedrock, extra keys that are not Converse request fields travel in additionalModelRequestFields.
Smart agent (planning + summarization)
import { createSmartAgent, createTool, fromLangchainModel } from "@cognipeer/agent-sdk";
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";
const echo = createTool({
name: "echo",
description: "Echo back user text",
schema: z.object({ text: z.string().min(1) }),
func: async ({ text }) => ({ echoed: text }),
maxExecutionsPerRun: null,
});
const model = fromLangchainModel(new ChatOpenAI({
model: "gpt-4o-mini",
apiKey: process.env.OPENAI_API_KEY,
}));
const agent = createSmartAgent({
name: "ResearchHelper",
model,
tools: [echo],
runtimeProfile: "balanced",
planning: { mode: "todo", replanPolicy: "on_failure" },
memory: { provider: "inMemory", scope: "session", writePolicy: "auto_important" },
summarization: { summaryTriggerTokens: 8000, summaryMode: "incremental" },
context: { policy: "hybrid", lastTurnsToKeep: 8 },
toolResponses: {
defaultPolicy: "summarize_archive",
toolResponseRetentionByTool: { read_skills: "keep_full" },
maxToolResponseChars: 4000,
maxToolResponseTokens: 1200,
},
limits: { maxToolCalls: 5, maxContextTokens: 12000 },
tracing: { enabled: true },
});
const result = await agent.invoke({
messages: [{ role: "user", content: "plan a greeting and send it via the echo tool" }],
toolHistory: [],
});
console.log(result.content);
Tool-response retention is lazy and summarizer-driven:
- Tool outputs are stored at full fidelity in
state.toolHistoryand are never reduced at tool-call time. - When the summarizer runs (context limits reached), old tool messages are rewritten in place according to
defaultPolicy(default:summarize_archive). The full payload is still recoverable viaget_tool_responseusing the execution id embedded in the placeholder. toolResponseRetentionByToollets you opt specific tools out of reduction (e.g.read_skills: "keep_full").criticalToolsare never reduced. The built-in list coversresponse,manage_todo_list, andget_tool_response.maxToolResponseChars/maxToolResponseTokensonly drive an eager hard-cap truncation when a single tool output is big enough to blow up the very next model call. The truncated head always points atget_tool_responsefor recovery.
The smart wrapper now supports runtime presets (fast, balanced, deep, research), custom profiles layered on top of a base preset, structured summarization, hybrid context compaction, skill-based progressive disclosure, configurable tool-response retention, in-memory fact storage, delegation limits, and an eval harness via runSmartAgentEvalHarness(...).
For large or optional tool catalogs, pass skills instead of binding every tool directly:
import { createSmartAgent, type Skill } from "@cognipeer/agent-sdk";
const pdfSkill: Skill = {
key: "builtin:pdf",
title: "PDF",
header: "read and summarize PDF files when the user references a PDF",
prompt: "Use pdf_read before pdf_summarize and preserve file ids in the answer.",
listToolIndex: () => [
{ name: "pdf_read", description: "Extract PDF text by file id" },
{ name: "pdf_summarize", description: "Summarize extracted PDF text" },
],
bindTools: (names) => bindPdfTools(names),
};
const agent = createSmartAgent({
model,
skills: [pdfSkill],
skillPolicy: { maxOpenSkills: 2, maxBoundToolsPerSkill: 8, maxBoundToolsTotal: 24 },
});
The model sees the skill header first. It calls open_skill to load the skill prompt and either bind a small skill immediately or get a tool index for bind_skill_tools.
You can also define a custom profile by extending a built-in preset and overriding only the knobs you need:
const agent = createSmartAgent({
name: "CustomPlanner",
model,
runtimeProfile: "custom",
customProfile: {
extends: "balanced",
limits: { maxToolCalls: 10, maxContextTokens: 18000 },
planning: { mode: "todo" },
context: { lastTurnsToKeep: 10 },
memory: { writePolicy: "manual" },
},
});
Reasoning & reflection
Both createAgent(...) and createSmartAgent(...) accept a unified reasoning config:
const agent = createSmartAgent({
model: fromNativeProvider(
createProvider({ provider: "openai", apiKey: process.env.OPENAI_API_KEY! }),
{ model: "gpt-5" },
),
tools: [echo],
reasoning: {
enabled: true,
level: "high",
native: { effort: "high" },
reflection: {
cadence: "after_tool",
mode: "piggyback",
maxTokens: 450,
keepLast: 4,
summarize: false,
},
},
});
const result = await agent.invoke({
messages: [{ role: "user", content: "Research the repo and propose the next implementation step." }],
}, {
onEvent(event) {
if (event.type === "reflection") {
console.log("reflection:", event.text);
}
},
});
console.log(result.state?.reflections?.at(-1)?.text);
What this does:
reasoning.nativepasses provider-specific reasoning knobs through the native provider layer.reasoning.reflectionadds a short plain-text reflection after qualifying turns without committing that note as a normal assistant message.- Reflection notes are persisted on
result.state.reflections; only the lastkeepLastare re-injected into the next prompt as synthetic system context.
Use this only with models/endpoints that actually support provider-native reasoning. Unsupported models usually return a provider error rather than silently degrading.
Base agent (minimal loop)
Prefer a tiny core without system prompt or summarization? Use createAgent:
import { createAgent, createTool, fromLangchainModel } from "@cognipeer/agent-sdk";
import { ChatOpenAI } from "@langchain/openai";
import { z } from "zod";
const echo = createTool({
name: "echo",
description: "Echo back",
schema: z.object({ text: z.string().min(1) }),
func: async ({ text }) => ({ echoed: text }),
});
const model = fromLangchainModel(new ChatOpenAI({ model: "gpt-4o-mini", apiKey: process.env.OPENAI_API_KEY }));
const agent = createAgent({
model,
tools: [echo],
limits: { maxToolCalls: 3, maxParallelTools: 2 },
});
const res = await agent.invoke({ messages: [{ role: "user", content: "say hi via echo" }] });
console.log(res.content);
Key capabilities
- Native provider layer – call OpenAI, Anthropic, Azure, Bedrock, Vertex, and any OpenAI-compatible API directly. No LangChain required. Unified
ChatCompletionRequest/ChatCompletionResponseschema with per-provider wire format conversion. - Full token tracking – every response surfaces
inputTokens,outputTokens,cachedInputTokens,cachedWriteTokens, andreasoningTokensfor all six providers. - Unified reasoning controls – enable provider-native reasoning (
reasoning.native) and post-tool reflection (reasoning.reflection) from one config surface. - Summarization pipeline – automatic chunking keeps tool call history within
contextTokenLimit/summaryTokenLimit, archiving originals soget_tool_responsecan fetch them later. - Retention controls – tool outputs can be kept full, reduced to structured previews, archived, or dropped based on size tiers, critical-tool fallback, per-tool overrides, and recent-response pinning.
- Planning discipline – when planning is enabled the system prompt distinguishes full plan writes from incremental plan updates and emits
planevents as todos change. - Structured output – supply
outputSchemaand the framework adds a hiddenresponsefinalize tool; parsed JSON is returned asresult.output. - Multi-agent orchestration – reuse agents via
agent.asTool({ toolName })or perform handoffs that swap runtimes mid-execution. - Sub-agents – pass
subagents/subagentPolicyto give the orchestratordelegate_to,spawn_subagent, andspawn_subagents_parallel; children inherit the parent model + observability and surface human-in-the-loop pauses for transparent resume. See Sub-Agents guide. - Ask the user – opt in with
humanInTheLoop: { askUser: true }to give the model anask_user_questiontool that pauses the run; resume by callingagent.resolveUserQuestion(state, { id, answers }). The globalallowFreeTextflag controls whether "Other" / typed answers are allowed. - MCP + LangChain tools – any object satisfying the minimal tool interface works; LangChain’s
Toolimplementations plug in directly. - Vision input – message parts accept base64 or URL images for multimodal requests.
- Observability hooks –
config.onEventsurfaces tool lifecycle, summarization, reflection, metadata, and final answer events for streaming UIs or CLIs.
Examples
Examples live under examples/ with per-folder READMEs. Build the package first (npm run build or npm run preexample:<name>).
| Folder | Focus |
|---|---|
basic/ |
Minimal tool call run with real model. |
tools/ |
Multiple tools, Tavily search integration, onEvent usage. |
tool-limit/ |
Hitting the global tool-call cap and finalize behavior. |
todo-planning/ |
Smart planning workflow with enforced TODO updates. |
summarization/ |
Token-threshold summarization walkthrough. |
summarize-context/ |
Summaries + get_tool_response raw retrieval. |
structured-output/ |
Zod schema finalize tool and parsed outputs. |
rewrite-summary/ |
Continue conversations after summaries are injected. |
ask-user/ |
Built-in ask_user_question tool, structured multi-choice prompt, resume with user's answer. |
multi-agent/ |
Delegating between agents via asTool. |
sub-agents/ |
Dynamic decomposition: delegate_to, spawn_subagent, spawn_subagents_parallel. |
handoff/ |
Explicit runtime handoffs. |
mcp-tavily/ |
MCP remote tool discovery. |
vision/ |
Text + image input using LangChain’s OpenAI bindings. |
To run examples:
# Install root dependencies
npm install
# Install example dependencies
cd examples
npm install
# Run an example from the examples directory
npm run example:basic
npm run example:tools
npm run example:multi-agent
Or run directly with tsx:
# From examples directory
OPENAI_API_KEY=... npx tsx basic/basic.ts
Architecture snapshot
The agent is a deterministic while-loop – no external graph runtime. Each turn flows through:
- resolver – normalize state (messages, counters, limits).
- contextSummarize (optional) – when token estimates exceed the active summarization threshold, archive heavy tool outputs.
- agent – invoke the model (binding tools when supported).
- tools – execute proposed tool calls with configurable parallelism.
- reflect (optional) – append a plain-text reflection after tool turns when
reasoning.reflectionis enabled. - toolLimitFinalize – if tool-call cap is hit, inject a system notice so the next assistant turn must answer directly.
The loop stops when the assistant produces a message without tool calls, a structured output finalize signal is observed, or a handoff transfers control. See docs/architecture/README.md for diagrams and heuristics.
API surface
Exported helpers (agent-sdk/src/index.ts):
Agent factories:
createSmartAgent(options)createAgent(options)createTool({ name, description?, schema, func, needsApproval?, approvalPrompt?, approvalDefaults?, maxExecutionsPerRun?, cache?, retry? })
Native providers (no LangChain):
createProvider(config)– factory for all six providersfromNativeProvider(provider, options?)– wraps a provider as aBaseChatModelOpenAIProvider,AnthropicProvider,AzureProvider,OpenAICompatibleProvider,BedrockProvider,VertexProvider- Types:
ChatCompletionRequest,ChatCompletionResponse,TokenUsage,ProviderConfig,ReasoningConfig,ReflectionRecord,ReflectionEvent
LangChain adapters (optional):
fromLangchainModel(model)withTools(model, tools)fromLangchainTools(tools)
Utilities:
buildSystemPrompt(extra?, planning?, name?)setTokenCounter,getTokenCounter,defaultTokenCounter– swap in a real tokenizer (tiktoken, etc.) globally or per-invokeresolveToolApprovalState,resolveUserQuestionState– pure helpers behindagent.resolveToolApproval/agent.resolveUserQuestionfor callers that want to apply a resolution outside the agent factory.createAskUserQuestionTool(stateRef, { allowFreeText, promptOverride })– exposed for advanced users that want to attach the human-in-the-loop tool manually instead of viahumanInTheLoop.askUser.- Node factories (
nodes/*), context helpers, token utilities, and full TypeScript types (SmartAgentOptions,SmartState,AgentInvokeResult,PendingUserQuestion,UserQuestionResolution, etc.).
SmartAgentOptions accepts the usual suspects (model, tools, limits, runtimeProfile, customProfile, useTodoList, summarization, reasoning, usageConverter, tracing, tokenCounter, costEstimator). See docs/api/ for detailed type references.
Budget surfaces (limits):
maxToolCalls,maxParallelTools,maxContextTokens– classic loop budgetsmaxTotalOutputTokens– cap on cumulative completion tokensmaxCostUsd– cumulative USD cost (requirescostEstimator)maxWallClockMs– overall wall-clock budget (also available asInvokeConfig.timeoutMs)
Tool-level controls (createTool):
maxExecutionsPerRun– cap successful executions of that tool within a single runcache– opt-in per-invoke result cache (trueor{ keyFn?, ttlMs? })retry– per-tool retry policy{ maxRetries?, backoffMs?, shouldRetry?, circuitBreakerThreshold? }
Provider-level controls (createProvider):
retry– automatic 429 / 5xx retry with exponential backoff andRetry-Aftersupportprompt_caching: { enabled: true, strategy?, ttl? }– Anthropiccache_controland BedrockcachePointbreakpoints on the system prompt and tools; the defaultstrategy: "auto"also caches the growing conversation (Anthropic automatic caching, a rolling Bedrock checkpoint),"static"keeps only the fixed prefix;ttl: "1h"for long pauses between calls. Cache reads cost a fraction of the input price on long tool-heavy runs
agent-sdk MCP questions
How do I add agent-sdk MCP to Claude Code?
Run claude mcp add agent-sdk -- npx -y @cognipeer/agent-sdk in your terminal. Add --scope user to make it available in every project.
How do I add agent-sdk MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What programming language is the agent-sdk written in?
The SDK is a TypeScript-first agent runtime.
Does the SDK require LangChain to work?
No, the SDK includes a built-in native provider layer that works directly with various providers without requiring LangChain.
Can I use this with different AI providers?
Yes, it supports OpenAI, Anthropic, Azure, Bedrock, Vertex, and any OpenAI-compatible API.
What are the Node.js requirements?
The SDK requires Node.js version 18.17 or higher.