Native SDK

Use the framework selector to see the matching packages and runtime provider code.

Use swy as a shorter alias for swytchcode in any of the commands below.

Choose your framework

Anthropic SDK

1. Install the CLI and SDK

   npm

    npm install -g swytchcode

   Windows

   irm https://cli.swytchcode.com/install.ps1 | iex

   macOS / Linux

   curl -fsSL https://cli.swytchcode.com/install.sh | sh

   JavaScript / TypeScript

   npm install @swytchcode/runtime @anthropic-ai/sdk

   Python

   pip install swytchcode-runtime anthropic python-dotenv

2. Initialize Swytchcode, fetch a toolkit, and enable a tool

   swy init creates the project’s tooling.json, swy get downloads the GitHub integration bundle, and swy add method resolves one of its methods into tooling.json.tools so it can actually be called. The example below stars a repo, so it also connects a GitHub account.

   swy init
   swy get github
   swy add method github.user.starred.update
   swy auth connect github

3. Initialize the provider

   JavaScript / TypeScript

   import "dotenv/config";
   import Anthropic from "@anthropic-ai/sdk";
   import { Swytchcode, TOOL_USE_INSTRUCTIONS } from "@swytchcode/runtime";
   import { AnthropicProvider } from "@swytchcode/runtime/providers/anthropic";
   
   async function runAgent() {
     const anthropic = new Anthropic();
   
     // 1. Initialize Swytchcode with the Anthropic provider
     const swx = new Swytchcode(new AnthropicProvider());
   
     // 2. Fetch the tools you want your agent to use (e.g., GitHub tools)
     const tools = await swx.tools.get({ toolkits: ["github"] });
   
     // 3. Build the system prompt: your own instructions plus TOOL_USE_INSTRUCTIONS,
     // which tells Claude to call the tool directly for action requests instead of
     // just describing what it would do
     const system = `You are a helpful assistant.\n\n${TOOL_USE_INSTRUCTIONS}`;
   
     const messages: Anthropic.MessageParam[] = [
       { role: "user", content: "Star the swytchcodehq/swytchcode-examples repo on GitHub for me." },
     ];
   
     // 4. Loop until Claude stops requesting tool calls: run any tool calls
     // Claude made and send the results back so it can keep working toward
     // a final natural-language reply instead of stopping after one round
     const MAX_TURNS = 10;
     let response: Anthropic.Message;
     for (let turn = 0; ; turn++) {
       if (turn >= MAX_TURNS) {
         throw new Error(`Exceeded ${MAX_TURNS} tool-use turns without a final reply`);
       }
   
       response = await anthropic.messages.create({
         model: "claude-sonnet-5",
         max_tokens: 1024,
         system,
         tools: tools,
         messages,
       });
       messages.push({ role: "assistant", content: response.content });
   
       if (response.stop_reason === "max_tokens") {
         throw new Error("Response truncated at max_tokens - increase the limit and retry");
       }
       if (response.stop_reason !== "tool_use") break;
   
       const toolResults = await swx.handleToolCalls(response);
       messages.push({ role: "user", content: toolResults as Anthropic.ToolResultBlockParam[] });
     }
   
     for (const block of response.content) {
       if (block.type === "text") console.log(block.text);
     }
   }
   
   runAgent();

   Python

   import os
   from dotenv import load_dotenv
   import anthropic
   from swytchcode_runtime import Swytchcode, TOOL_USE_INSTRUCTIONS
   from swytchcode_runtime.providers.anthropic import AnthropicProvider
   
   load_dotenv()  # Loads .env automatically
   
   def run_agent():
       client = anthropic.Anthropic()
   
       # 1. Initialize Swytchcode with the Anthropic provider
       swx = Swytchcode(provider=AnthropicProvider())
   
       # 2. Fetch the tools you want your agent to use (e.g., GitHub tools)
       tools = swx.tools.get(toolkits=["github"])
   
       # 3. Build the system prompt: your own instructions plus TOOL_USE_INSTRUCTIONS,
       # which tells Claude to call the tool directly for action requests instead of
       # just describing what it would do
       system = f"You are a helpful assistant.\n\n{TOOL_USE_INSTRUCTIONS}"
   
       messages = [{"role": "user", "content": "Star the swytchcodehq/swytchcode-examples repo on GitHub for me."}]
   
       # 4. Loop until Claude stops requesting tool calls: run any tool calls
       # Claude made and send the results back so it can keep working toward
       # a final natural-language reply instead of stopping after one round
       while True:
           response = client.messages.create(
               model="claude-sonnet-5",
               max_tokens=1024,
               system=system,
               tools=tools,
               messages=messages,
           )
           messages.append({"role": "assistant", "content": response.content})
   
           if response.stop_reason == "max_tokens":
               raise RuntimeError("Response truncated at max_tokens - increase the limit and retry")
           if response.stop_reason != "tool_use":
               break
   
           tool_results = swx.handle_tool_calls(response)
           messages.append({"role": "user", "content": tool_results})
   
       for block in response.content:
           if block.type == "text":
               print(block.text)
   
   if __name__ == "__main__":
       run_agent()

4. Handle the tool loop

   Pass the tool result back to Claude. For a manual loop in Python, use swx.handle_tool_calls(response) to execute tool calls and create tool_result blocks.

5. Run the file

   Save the example as main.js or main.py, then run:

   JavaScript / TypeScript

   node main.js

   Python

   python main.py

OpenAI Agents

1. Install the CLI and SDK

   npm

   npm install -g swytchcode

   Windows

   irm https://cli.swytchcode.com/install.ps1 | iex

   macOS / Linux

   curl -fsSL https://cli.swytchcode.com/install.sh | sh

   JavaScript / TypeScript

   npm install @swytchcode/runtime @openai/agents

   Python

   pip install swytchcode-runtime openai-agents python-dotenv

2. Initialize Swytchcode and fetch a toolkit

   swy init creates the project’s tooling.json; swy get github downloads the GitHub integration bundle that tools.get reads from below.

   swy init
   swy get github

3. Initialize the provider

   JavaScript / TypeScript

   import { Swytchcode } from '@swytchcode/runtime';
   import { OpenAIAgentsProvider } from '@swytchcode/runtime/providers/openai-agents';
   
   const swx = new Swytchcode(new OpenAIAgentsProvider());
   const tools = await swx.tools.get({ toolkits: ['github'] });

   Python

   from swytchcode_runtime import Swytchcode
   from swytchcode_runtime.providers.openai_agents import OpenAIAgentsProvider
   
   swx = Swytchcode(provider=OpenAIAgentsProvider())
   tools = swx.tools.get(toolkits=['github'])

4. Pass tools to your agent

   The returned tools use the native OpenAI Agents format. Pass them into your agent and let Swytchcode handle execution, authentication, and policy checks.

5. Run the file

   Save the example as main.js or main.py, then run the matching command:

   JavaScript / TypeScript

   node main.js

   Python

   python main.py

Vercel AI SDK

1. Install the CLI and SDK

   npm

   npm install -g swytchcode

   Windows

   irm https://cli.swytchcode.com/install.ps1 | iex

   macOS / Linux

   curl -fsSL https://cli.swytchcode.com/install.sh | sh

   npm install @swytchcode/runtime ai @ai-sdk/openai

2. Initialize Swytchcode and fetch a toolkit

   swy init creates the project’s tooling.json; swy get github downloads the GitHub integration bundle that tools.get reads from below.

   swy init
   swy get github

3. Initialize the provider and run the model

   import { openai } from '@ai-sdk/openai';
   import { generateText } from 'ai';
   import { Swytchcode } from '@swytchcode/runtime';
   import { VercelProvider } from '@swytchcode/runtime/providers/vercel';
   
   const swx = new Swytchcode(new VercelProvider());
   const tools = await swx.tools.get({ toolkits: ['github'] });
   
   const result = await generateText({
     model: openai('gpt-4.1'),
     tools,
     prompt: 'Summarize my open pull requests from GitHub.',
   });
   
   console.log(result.text);

4. Run the file

   Save the example as main.js, then run:

   node main.js

Other providers

Choose a framework-specific guide to see its provider and tool setup:

• LangGraph
• CrewAI
• OpenAI SDK
• Anthropic SDK
• Runtime SDK reference

Where to go next

Browse all examples →

Gmail Assistant

Searches, reads, drafts, and sends Gmail messages through an Anthropic tool-use loop powered by Swytchcode.

Star Repo Agent

Minimal OpenAI Agents SDK example that stars a GitHub repo through Swytchcode-brokered OAuth.

OpenAI SDK

Integrate Swytchcode tools with the OpenAI Agents SDK to build reliable agents.

Anthropic SDK

Connect Claude-based agents to trusted tools using the Anthropic integration.

LangGraph

Build stateful, multi-step workflows and execute tools through Swytchcode.

CrewAI

Enable CrewAI agents to discover and execute trusted tools.

Runtime SDKs

Learn how the JavaScript and Python Runtime SDKs power tool execution across frameworks.