Experimental

Building on Amplifier
Just Got Easier

Amplifier SDK — Type-safe client libraries for TypeScript and Python

January 2026

The Problem

Raw APIs Are Nobody's Friend

Amplifier's runtime exposes powerful HTTP + SSE APIs. But without an SDK, every developer faces the same pain:

💥

Type Chaos

No IntelliSense, no autocomplete — just string soup and crossed fingers

🌀

Streaming Headaches

SSE parsing, connection management, error recovery — all on you

🧩

Protocol Complexity

Session lifecycle, event types, approval flows — learn it all from scratch

🔄

Reinventing the Wheel

Every developer writes their own HTTP plumbing, each with their own bugs

🌐

Language Mismatch

The API speaks JSON over HTTP; your app speaks objects and promises

The Solution

SDKs That Feel Like Home

Idiomatic, fully-typed client libraries that handle all HTTP/SSE complexity for you.

🛡️

Type Safety

Full TypeScript types & Python type hints

⚡

Streaming

Async iterators & generators built in

✨

Ergonomic

snake_case / camelCase — your language, your style

🔄

Sessions

Create, prompt, stream, cleanup — handled

✅

Approvals

Agent permission flows in one method call

🇹🇸

TypeScript SDK

Promises, camelCase, for await...of

🐍

Python SDK

async with, snake_case, async for

TypeScript

The 30-Second Demo

Create a session, stream a response, clean up. That's it.

TypeScript

import { AmplifierClient } from "amplifier-sdk";

const client = new AmplifierClient();

// Create a session
const session = await client.createSession({ bundle: "foundation" });

// Stream a response
for await (const event of client.prompt(session.id, "Write a haiku about coding")) {
  if (event.type === "content.delta") {
    process.stdout.write(event.data.delta as string);
  }
}

// Clean up
await client.deleteSession(session.id);

No HTTP clients. No SSE parsers. No protocol docs. Just clean, typed code.

Python

Same Power, Pythonic Style

Context managers, snake_case, async for — everything you'd expect.

Python

import asyncio
from amplifier_sdk import AmplifierClient

async def main():
    async with AmplifierClient() as client:
        # Create a session
        session = await client.create_session(bundle="foundation")

        # Stream a response
        async for event in client.prompt(session.id, "Write a haiku about coding"):
            if event.type == "content.delta":
                print(event.data.get("delta", ""), end="", flush=True)

        # Clean up
        await client.delete_session(session.id)

asyncio.run(main())

Patterns

Real-World Usage

One-Shot Execution

# Quick answer — session auto-managed
async with AmplifierClient() as client:
    response = await client.run(
        "What's the weather in Paris?"
    )
    print(response.content)

Tool Call Tracking

// See what the agent is doing
for await (const ev of client.prompt(
  sid, "Analyze this codebase"
)) {
  if (ev.type === "tool.call")
    console.log(`Tool: ${ev.data.tool_name}`);
}

Approval Flows — Let users control what agents can do

async for event in client.prompt(session.id, "Delete old logs"):
    if event.type == "approval.required":
        choice = input(f"Allow? {event.data['prompt']} (y/n): ")
        await client.respond_approval(
            session.id, event.data["request_id"], choice
        )

Architecture

Clean Separation of Concerns

The SDK sits between your app and the runtime, handling all protocol details.

Your Application

Chat apps, automation tools, agent interfaces, custom integrations

↓

Amplifier SDK
Type-safe methods · Streaming abstraction · Session lifecycle

↓

amplifier-app-runtime

REST API + SSE streaming · Session management · localhost:4096

↓

amplifier-foundation + amplifier-core

AI agents & tools · Provider integrations · Core capabilities

Getting Started

Up and Running in 3 Steps

1

Start the Runtime

Fire up the Amplifier app runtime on your machine.

cd amplifier-app-runtime uv run python -m amplifier_app_runtime.cli --port 4096

2

Install the SDK

Pick your language and install the package.

# TypeScript npm install amplifier-sdk # Python pip install amplifier-sdk

3

Build Something

Create a session, send a prompt, stream the response.

const client = new AmplifierClient(); const session = await client.createSession(); for await (const ev of client.prompt(session.id, "Go!")) { ... }

Roadmap

What's Next

This is just the beginning. The SDK is ready to use today, but we're actively building more.

🌍

More Languages

Go, Rust, Java — tell us what you need

📊

Richer Events

Progress tracking, cost monitoring, debug traces

🔗

Webhooks

Async execution patterns for long-running tasks

🎨

UI Components

Drop-in React/Vue components for common patterns

📖

More Examples

Chat apps, automation tools, agent orchestrators

🤝

Community

Your feedback shapes everything — try it, break it, tell us

Both SDKs are open source

PRs welcome · Issues encouraged · Feedback essential

Appendix

Sources & Methodology

Data As Of

February 20, 2026

Feature Status

Experimental — SDK is early-stage, APIs may change

Research Performed

find ~/dev/ANext -maxdepth 2 -name "*sdk*" — no local results

git log --grep="SDK" in amplifier-foundation — no results

Repository referenced: github.com/manojp99/amplifier-sdk (external, not verified locally)

Primary Contributors

manojp99 (based on repository URL)

Content Source

Original blog post content from January 30, 2026 announcement. Claims preserved as-written; no independent verification of SDK package availability was performed.

Known Gaps

• No local SDK repository found in workspace
• Content based on existing blog post claims
• SDK package availability on npm/PyPI not independently verified
• No commit history or velocity data available

The SDK Is Ready.
What Will You Build?

Stop wrestling with HTTP and SSE.
Start shipping your application.

View on GitHub

TypeScript Docs · Python Docs · Examples · Discussions

Building on AmplifierJust Got Easier