Awaken Agents · tested with the official Anthropic SDK

Open source · stable release coming soon Apache-2.0

Use one Agent platform from first run to enterprise deployment.

Publish an Agent, keep one durable Session, control resources and permissions, resume after interruption, and place control, data, and execution inside infrastructure you operate.

Run the Agents quickstart ★ View and star on GitHub

Create an Agent, adopt a supported one, or connect existing behavior, then make one application create, run, reconnect, and reopen the same Session. When you build the next application, reuse the Agent, Session, resource, permission, Worker, Sandbox, and recovery foundation instead of creating another backend.

Migrating an existing app? Check the compatibility surface and known differences →

First successful run

Reach one inspectable Session before you evaluate architecture.

  1. 1

    Start

    Run the local AllInOne service with a durable data directory.

  2. 2

    Publish

    Connect a model, publish one Agent, and create a Session.

  3. 3

    Verify

    See agent.message and session.status_idle, then reopen the committed events after restart.

Run the Agents quickstart →

What changes for your team

Build the Agent product your customers see. Reuse the platform work behind it.

Your application keeps its experience, domain state, workflow, acceptance, and commercial relationship. Awaken supplies the reusable Agent lifecycle underneath.

Ship one real Agent application

Publish an Agent, create and reopen the same Session, connect resources and permissions, and operate execution without assembling another backend.

Agent publication · Session and events · resources · Worker and Sandbox

Keep existing application investment

Retain the tested official SDK model and connect web, copilot, or Agent-to-Agent surfaces to the same published Agent instead of copying it.

Managed Agents · AI SDK · AG-UI · A2A

Keep differentiated Agent behavior

Choose Awaken Native execution, a supported ACP runtime, or a remote A2A Agent without creating another Session authority.

Native · ACP · outbound A2A

Run inside enterprise boundaries

Place control, Session data, credentials, model routes, Workers, and Sandboxes inside the approved infrastructure and responsibility boundary.

Self-hosted · enterprise delivery · hosted preview

Managed-compatible. Awaken-enhanced.

Keep the application contract. Choose how the platform connects, executes, and runs.

Anthropic Managed Agents defines a useful application contract. Awaken implements a tested baseline, then adds explicit client, execution, model, and deployment choices around one Agent and Session authority.

Adopt with the official SDK model

Managed Agents baseline

Use the official Managed Agents API and SDK resource model.

Awaken extension

Point a reviewed SDK version to Awaken, configure Awaken authentication, and keep the named compatible request and response shapes.

What this changes: Reduce migration work while keeping exact differences reviewable

Connect more than one application surface

Managed Agents baseline

Managed Agents clients enter through the Managed API.

Awaken extension

Managed Agents, AI SDK, AG-UI, and A2A project the same published Agent and committed Session history.

What this changes: Reuse one Agent across backend, web, copilot, and Agent-to-Agent products

Choose the execution behavior

Managed Agents baseline

Use a managed sandbox or self-hosted environment worker inside the Anthropic service model.

Awaken extension

Select Native execution, a supported ACP Agent runtime, or a remote A2A endpoint without changing the client contract.

What this changes: Preserve existing Agent behavior and select the right execution path per product

Choose who owns the platform boundary

Managed Agents baseline

The service control plane and persistent service are operated by Anthropic.

Awaken extension

Deploy and operate the API, Session data, credentials, model routes, Workers, and Sandboxes yourself or through an AwakenWorks delivery mode.

What this changes: Meet enterprise deployment and operating-responsibility requirements

Current Awaken Console · verified release build

The overview turns setup into five visible steps: connect a model, publish an Agent, run a Session, inspect evidence, then connect an application.
Build and publish in Console Give the Agent a readable name, choose a runnable model and task, test the draft, then review the exact publication change.
Connect a model before you build Verify a provider credential and endpoint, import its model catalog, and expose only models the runtime can execute.
Connect through the protocol you use Open the protocol-specific guide, create the right API key for protected deployments, and inspect the same Session in Console.
Turn a tested Agent into repeatable work Each scheduled or manual trigger creates its own inspectable Session, with a direct path from the run to its result.

Captured from Awaken v1.0.0-dev release UI at revision 50d5035c68456c9106626f748cf4c169c2057beb. Controlled local data is shown; these are product screens, not customer activity.

Choose the next technical decision

Keep the product decision short. Open the exact guide when you need depth.

Start with the verified run above. The documentation owns compatibility versions, architecture and recovery, deployment procedure, and Runtime internals so this page can stay focused on whether Agents fits your product.

Migrate an existing client

Check reviewed SDK versions, supported resources, required selectors, and known differences before changing an application.

Review compatibility →

Review authority and recovery

Follow publication, Session, dispatch, Worker execution, committed facts, failures, and recovery through their owning boundaries.

Read the architecture →

Choose a deployment boundary

Plan AllInOne or split services, data and credential custody, Workers, Sandboxes, observation, backup, and operating ownership.

Open the self-hosting guide →

Extend the execution engine

Enter Runtime documentation only when you need to change Agent-loop, tool, plugin, state, or execution-backend behavior.

Open Runtime internals →

Start with one Session. Expand only when the operating model fits.

Run the open-source code today. The first stable release is coming soon; talk with us about architecture, integration, and operating responsibility when you need help.

Run the Agents quickstart Enterprise deployment services