What's new

See where a run’s time went

The Studio run drawer has a new Timing view next to Events. It breaks a run into consecutive phases: ingress, queueing, dispatch, handler time, durability, coordination, and finalization. Each phase is labeled measured, inferred, or unknown, so you can tell which numbers come straight from telemetry and which are estimates.

Activity now sits in the workspace’s main navigation, as it already does for projects, instead of under Workspace Settings.

Go SDK 0.6 and 0.7

• Skills: Go agents can now discover and load SKILL.md skills progressively, pick up guidance from AGENTS.md files in order, and get sandbox tools automatically. See Skills.
• TaskWithKey: gives durable work a stable identity of your choosing, so parallel, reordered, or repeated tasks with the same name replay correctly.
• OTLP logs: application and component logs can be exported through OTLP, tagged with AGNT5 resource and run attributes.
• Gemini tools: function declarations, function calls, and tool results now round-trip with their call IDs and thought signatures.

CLI

• agnt5 create, init, and link can now run without a terminal. --workspace and -y/--yes let you skip the prompts, so they work in CI and agent sessions. When a required value is missing, the error now names the flag to pass.
• Streaming commands such as agnt5 logs --follow no longer disconnect after 60 seconds.
• agnt5 run --env <env> now finds the deployment that is actually serving that environment.
• agnt5 components authenticates correctly and parses responses as expected.

Heads up: run event names

Durable steps, model calls, tool calls, and child agents are now recorded by the runtime as one journal entry per activation, and replays add nothing to the journal. Model call events are now named lm.completed and lm.failed, replacing lm.call.*. The built-in trace assertions in all three SDKs use the new names. If you filter run events by name, update those filters.

SDK releases

• Python 0.11.0 – 0.11.1: concurrent asyncio tasks keep separate durable step state, and durable sleeps can resume typed outputs such as Pydantic models.
• TypeScript 0.8.0 – 0.8.1: FunctionRegistry is exported from the package root, and Cloudflare Workers bundles pick an edge-safe loader.
• Go 0.5.0 – 0.7.0

July brought serverless endpoints into beta, unified prompt caching across providers, and evals parity for the Go SDK.

Serverless endpoints (beta)

You can now run AGNT5 functions, workflows, tools, and agents from an HTTP endpoint on your own serverless host, instead of from a long-running worker. AGNT5 signs each invocation, retries failed calls, and replays from checkpoints on re-invocation.

agnt5 serverless init adds the handler files to an existing project. --provider picks the host and --runtime picks the language:

agnt5 serverless init --provider cloudflare --name hello-agnt5
agnt5 serverless init --provider cloud-run --runtime python

• Hosts: Cloudflare Workers and Vercel for TypeScript; Vercel and Cloud Run for Python; Cloud Run for Go; any HTTPS host for all three SDKs. AWS Lambda (through the Lambda Web Adapter) is in preview.
• Python frameworks: adapters for ASGI, FastAPI, Starlette, WSGI, Flask, and Django.
• Before you register: agnt5 serverless validate checks a deployed endpoint’s manifest, and agnt5 serverless status --verify can gate promotion in CI.

Batch policies aren’t supported during the beta, so keep batch work on persistent workers. See Serverless endpoints and the support matrix.

One prompt caching option across providers

Pass cache to lm.generate, lm.stream, or an Agent, and AGNT5 translates it into the request format Anthropic, OpenAI, or Gemini expects. Cache hits are reported in response.usage.cached_tokens for all three.

from agnt5 import Agent, lm

agent = Agent(
    name="support_agent",
    model="anthropic/claude-sonnet-4-6",
    instructions=LONG_STABLE_INSTRUCTIONS,
    cache=lm.PromptCache(ttl="1h"),
)

The same option is available in TypeScript and Go. See Prompt caching.

Evals in the Go SDK

Go SDK 0.3.0 adds the same eval tooling as Python and TypeScript: 25 deterministic built-in scorers, five LLM-as-judge scorers, trace and tool-trajectory assertions, versioned evaluator presets, and concurrent batch evaluation. All three SDKs are tested against the same golden fixtures for the deterministic scorers. Go also now has its own examples throughout the docs, next to Python and TypeScript.

Models

• Moonshot AI is now an OpenAI-compatible provider in all three SDKs. Set MOONSHOT_API_KEY to use Kimi models.
• Gemini tool-call parsing has been fixed, and support for Amazon Bedrock models has been expanded.
• OpenAI agent responses now stream incrementally even when tools are registered.

CLI

• Homebrew installs work on macOS and Linux: brew install agnt5dev/agnt5/agnt5.
• agnt5 upgrade updates the CLI in place.
• agnt5 deployment list lists a project’s deployments, newest first.
• agnt5 deploy now waits for the deployment to be ready before reporting success. If a worker crashes during startup, the deploy fails with the crash reason.
• Commands that make changes now reject unrecognized arguments.

Studio and platform

• Secret values are masked, with a reveal action, and you can edit one secret across several environments.
• The model picker shows provider icons and puts your starred models first.
• Project secrets are now scoped to workspace membership instead of to whoever created them.
• Go code-bundle deployments get ready faster, dropping from about 168 seconds to under 35 in our tests.

SDK releases

• Python 0.9.1 – 0.9.7: prebuilt wheels for Linux x64, Linux ARM64, and macOS ARM64.
• TypeScript 0.6.1 – 0.6.6: native packages for the same three platforms.
• Go 0.2.0 – 0.3.1

Project templates now target Python 3.14 and Node 26.

Agents now maintain durable conversation history across sessions with intelligent context window management. No more context loss when conversations span days or exceed token limits.

Automatic Context Summarization

When conversation history approaches the LLM’s token limit, AGNT5 automatically summarizes older messages while preserving recent exchanges verbatim:

@agent()
class SupportAgent:
    async def handle_message(self, user_id: str, message: str):
        # Context automatically managed
        response = await self.chat(message)
        return response

The agent maintains full conversation history in durable storage. Recent messages stay intact for immediate context. Older messages get compressed through summarization. The LLM sees a seamless conversation thread that fits within token limits.

Why Context Matters

Long-running agent conversations — customer support, research assistants, coding copilots — require persistent memory. Users expect agents to remember previous interactions, not restart from scratch each session.

With automatic context management, your agents scale to conversations of any length. The complexity of token counting, summarization, and history management becomes invisible.

Read the agent documentation for implementation details.

Entity state management now supports Python’s TypedDict, bringing full type safety and IDE autocomplete to your durable entities.

The Problem

Previously, entity state was untyped — a plain dictionary that could hold any structure. This worked, but required manual validation and provided no IDE support:

@entity()
class UserSession:
    async def update_preferences(self, key: str, value: any):
        # What fields exist in self.state? No autocomplete to help.
        self.state[key] = value

The Solution

Define your state structure with TypedDict, and the SDK enforces it at runtime:

from typing import TypedDict

class SessionState(TypedDict):
    user_id: str
    preferences: dict[str, str]
    last_active: int

@entity()
class UserSession:
    state: SessionState

    async def update_preference(self, key: str, value: str):
        # Full autocomplete on self.state.preferences
        self.state["preferences"][key] = value

Type checking happens automatically. Invalid state updates fail fast with clear error messages. Your IDE provides autocomplete for all state fields.

Read the entity documentation to learn more about type-safe state management.

When workflows span hours or days, state persistence becomes critical. This release strengthens AGNT5’s checkpoint recovery system to handle complex state transitions more reliably.

What Changed

We’ve redesigned how workflow state gets persisted during execution. Previously, checkpoints were created after each function invocation. Now, checkpoints capture the complete workflow context — including local variables, pending tasks, and execution history.

@workflow()
async def research_pipeline(topic: str):
    # Checkpoint created here with full context
    sources = await gather_sources(topic)

    # If failure occurs here, workflow resumes with sources intact
    summaries = await summarize_sources(sources)

    return await synthesize_report(summaries)

This means when a workflow resumes after a failure, it picks up exactly where it left off. No re-execution of completed steps. No lost progress.

Why This Matters

Long-running AI workflows often fail mid-execution — API timeouts, rate limits, infrastructure issues. With enhanced checkpoint recovery, these failures no longer mean starting over.

Your workflows become truly durable. Pause them. Resume them. Replay them with different code. The execution history is the source of truth.

Learn more in the workflow documentation.