Blazing Agents

Blazing Agents is infrastructure for running production Agents. It is for developers building agent-powered applications who want to focus on Agent behavior while the platform manages execution and durable state.

Build the Agent; the platform runs it

Blazing Agents owns Agent configuration and execution, Sessions and Turns, Skills and Tools, secure Sandboxes, background Tasks, and usage tracking.

Your application owns end-user authentication and authorization, the product UI, business rules, and the mapping between its users and Blazing Agents resource IDs. An optional userId attributes resources and usage to one of your end-users for filtering and reporting; it is not an authorization boundary.

How Blazing Agents fits your application

The core path is Agent → Session → Turn → streamed output and usage:

• An Agent is the configuration for model behavior and available capabilities.
• A Session is one stored conversation for an Agent. An interactive Session's record is created only when its first Turn succeeds.
• A Turn is one metered execution, which can stream output and records usage after it finishes.

A background Task is a named instruction that runs an Agent asynchronously without your application starting an interactive Session. The platform creates a fresh Session to hold the Task transcript before its Turn begins.

Run your first Agent

This compact example shows the product shape: create the smallest valid Agent, start a chat Turn, capture its server-minted Session ID, and relay the stream. Keep the API key and Session ID on your backend; see Setup for installation and credential configuration.

import { BlazingAgents, type UIMessage } from "@blazing-agents/sdk";

const client = new BlazingAgents({
  apiKey: process.env.BLAZING_AGENTS_API_KEY!,
});

export async function runAgent(): Promise<Response> {
  const agent = await client.agents.create({ name: "Support Agent" });
  const message = {
    id: crypto.randomUUID(),
    role: "user",
    parts: [{ type: "text", text: "How can you help?" }],
  } satisfies UIMessage;

  const result = await client.chat({ agentId: agent.id, message });
  console.log(await result.sessionId);
  return result.toResponse();
}

The log shows an ss_... Session ID minted by the server, and the returned Response relays the Turn as server-sent events (SSE).

What you can build

Choose an interface

Explore the documentation

• Start with the Quickstart to create an Agent and run its first Turn.
• Use Getting Started for the complete setup and integration path.
• Browse Capabilities to understand what the platform can do.
• Follow Guides for outcome-oriented implementation steps.
• Open Reference for exact SDK, REST, and protocol contracts.
• Visit Developer Tools for alternative ways to work with the platform.

Related guides

• Build a chat endpoint
• Create and attach a Skill
• Run a background Task

Reference

• TypeScript SDK reference
• REST API reference