run-llama/llama-agents

This system is a comprehensive framework for building, deploying, and managing durable AI agent workflows, centered around the LlamaIndex ecosystem. It provides a Kubernetes-native control plane and operator to orchestrate agent deployments, alongside a flexible server runtime that supports persistent state, human-in-the-loop interactions, and multiple execution backends like DBOS and AWS Bedrock. The platform includes a CLI for management, a Python client for programmatic interaction, and extensive tooling for observability, visualization, and local development.

14 changes.

This period established the LlamaAgents monorepo structure, unifying Python and TypeScript tooling across multiple agent-related packages. It introduced the core workflow engine with enhanced serialization, visualization, and state management capabilities, supported by comprehensive test suites. The work also delivered extensive documentation and runnable examples for server deployment, client interaction, and observability.

38 changes.

This period focused on establishing the core infrastructure for the Llama Agents ecosystem, introducing a new server, control plane, and Kubernetes operator for deployment and management. Significant work was done to enable durable, distributed workflow execution through DBOS and persistent storage backends, alongside comprehensive integration testing across these new components.

The examples/dbos directory now includes a suite of runnable demonstrations for durable workflow execution using DBOS. These examples cover a quick-start server using SQLite for zero-setup testing, a standalone script demonstrating checkpointing and resume capabilities, a multi-replica setup backed by Postgres (with Docker Compose) for high-availability scenarios, and a demo showing how idle workflows are released from memory and resumed. Users can now explore crash recovery, resumable runs, and multi-replica coordination directly within the examples.

examples/dbos · high confidence

New Dockerfiles have been added to containerize the application's core components and testing infrastructure. The main Dockerfile now supports building and running the control plane (exposing ports 8000 and 8001) and the app server (exposing port 8080), utilizing Python 3.12-slim and the uv package manager. Additionally, a Dockerfile for the Kubernetes operator is provided, building a Go binary from source and packaging it in a distroless image. A separate Dockerfile and entrypoint script are also introduced to simulate corporate MITM proxy scenarios for testing native TLS mode.

docker · high confidence

Added self-contained example scripts in the \examples/client\ directory demonstrating how to use the \llama\_agents.client.WorkflowClient\ to interact with a running \WorkflowServer\. The \base\ subfolder provides a minimal example for submitting runs, streaming events, and retrieving results, while the \human\_in\_the\_loop\ subfolder illustrates handling workflows that pause for human input via \InputRequiredEvent\ and \HumanResponseEvent\.

examples/client · high confidence

The \llama-agents\ Helm chart (version 0.12.6) is now available, providing a standardized way to deploy the Llama Agents control plane and operator. This chart introduces several key capabilities: an optional \s3proxy\ sidecar for using non-AWS object storage backends, a dedicated \apps.namespace\ setting to isolate \LlamaDeployment\ resources from the operator, and configurable network policies with DNS and private-range blocking. It also includes support for Horizontal Pod Autoscalers (HPA) for both the control plane and operator, and manages CRD version compatibility via a pinned \crds.version\ field.

charts/llama-agents · high confidence

This change adds a new \llama-agents-agentcore\ package that enables deploying and running LlamaIndex Workflows on the AWS Bedrock AgentCore Runtime. It provides an \AgentCoreService\ and \AgentCoreRuntimeDecorator\ to wrap workflow execution as async tasks, maintaining container liveness for the full workflow duration. The entrypoint supports session-based idempotency, where \context.session\_id\ maps to workflow handlers, allowing re-invocations to return cached results or await running workflows. A high-level \AgentCoreDeployer\ handles the full lifecycle including container building via CodeBuild, pushing to ECR, and managing the AgentCore Runtime. The service also supports action-based routing for operations like running workflows, polling results, sending events, and cancellation, with SQLite used as the default workflow store.

packages/llama-agents-agentcore/src · high confidence

This package provides a new DBOS-based runtime adapter for LlamaIndex workflows, enabling durable execution with automatic step recording, replay, and distributed worker support. Key capabilities include per-worker concurrency limits enforced via DBOS queues, an idle-release mechanism that uses 'continue-as-new' to free memory while preserving state, and cross-replica event delivery and streaming through a shared Postgres database. The adapter supports horizontal scaling via executor IDs, handles crash recovery for idle releases, and ensures deterministic replay by seeding retry jitter with the run ID.

packages/llama-agents-dbos · high confidence

This change adds a new DBOS plugin for LlamaIndex Workflows, enabling durable, stateful workflow execution backed by a database. The implementation includes a DBOSRuntime that manages workflow state, task journals, and lifecycle coordination (active, releasing, released, resuming) across replicas. It supports both Postgres and SQLite via dedicated migration scripts and CRUD layers, and introduces an ExecutorLeaseManager for concurrency control and an idle-release mechanism to gracefully pause and resume workflows. Users can now run workflows with persistent state and crash recovery using DBOS as the backend.

packages/llama-agents-dbos/src · high confidence

This change adds the \llama-agents-appserver\ package, providing a FastAPI-based application server that serves as the runtime for Llama Deploy. It introduces a new deployment lifecycle, including a bootstrap process that can clone repositories, install dependencies, build UI assets, and package results into tarballs for S3 storage. The server exposes REST and WebSocket APIs to manage workflow tasks, sessions, and events, supporting both local SQLite and cloud-based persistence. It also features a UI proxy mode for development, structured logging with correlation IDs, and configurable CORS and health-check endpoints.

packages/llama-agents-appserver/src · high confidence

This change introduces the \LlamaDeployment\ and \LlamaDeploymentTemplate\ Custom Resource Definitions (CRDs) for the llama-agents operator, allowing users to define deployment configurations and pod template overlays via Kubernetes resources. A new \llama-agents-crds\ Helm chart (v0.7.2) is provided to manage the lifecycle of these CRDs, ensuring they are updated during \helm upgrade\ while remaining intact during \helm uninstall\ via the \helm.sh/resource-policy: keep\ annotation. The \LlamaDeployment\ CRD supports fields for specifying repository URLs, git references, container images, and build generation counters to trigger retries, while the \LlamaDeploymentTemplate\ CRD allows users to define default pod spec overlays (e.g., node selectors, tolerations) that merge with operator-computed defaults.

charts/llama-agents-crds, operator/api, operator/cmd · high confidence

The control plane now includes a dedicated FastAPI build API for managing build artifacts (upload, download, existence checks) backed by S3, along with a Git code-repo service that stores bare repositories as tarballs in S3 and serves them via a dulwich-based WSGI layer. A new backup subsystem provides encrypted (.tar.gz) archives of LlamaDeployment CRs and secrets with S3 storage support, including AES-256-GCM encryption and metadata cleaning. These additions introduce new endpoints and internal services for build artifact lifecycle, Git repository persistence, and backup/restore capabilities.

packages/llama-agents-control-plane/src · high confidence

The new \src/dev\_cli\ package provides a centralized developer tool for the repository, featuring a CLI entry point that defaults to running pytest when no subcommand is specified. It introduces automated versioning capabilities, including utilities to convert between semver and PEP 440 formats, infer metadata from git tags, and detect semantic change types. The tool also handles release operations by managing changesets, publishing to PyPI, Docker, and Helm, and updating debugger assets in \index.html\.

_src/dev\cli · high confidence

The WorkflowClient now supports typed introspection of workflow schemas and graphs, allowing users to inspect available workflows and their structures programmatically. Additionally, completion polling has been added to the client, enabling users to wait for workflow handlers to finish and retrieve their final results reliably.

_packages/llama-agents-client/src/llama\agents/client · high confidence

The server runtime now persists workflow ticks and events to a configurable store, enabling durable execution and state recovery across server restarts. It automatically releases idle workflow handlers from memory after a configurable timeout and reloads them on demand, improving resource efficiency. Additionally, all emitted events are recorded with metadata for external querying, and terminal events (failures, timeouts, cancellations) are logged and reflected in the handler status.

_packages/llama-agents-server/src/llama\_agents/server/\runtime · high confidence

The \llama-agents-client\ package now includes a \protocol\ module that defines shared data structures and serialization logic for client-server communication. This adds Pydantic models for managing workflow state (such as \HandlerData\, \Status\, and \HealthResponse\) and a robust event envelope system (\EventEnvelopeWithMetadata\, \EventEnvelope\) that handles the serialization, deserialization, and type resolution of workflow events, enabling clients to reliably decode API events and stored results.

_packages/llama-agents-client/src/llama\agents/client/protocol · high confidence

Added a new Docker example in the \examples/docker\ directory that demonstrates how to containerize and run a \WorkflowServer\. The entry includes a \Dockerfile\ based on Python 3.13 Alpine, a sample \app.py\ defining a \GreetingWorkflow\ with streaming events, and a \README.md\ with build and run instructions. This allows users to easily deploy and test workflow servers in isolated container environments.

examples/docker · high confidence

Added a self-contained example in \examples/k8s-otel\ that deploys LlamaIndex Workflows on Kubernetes using DBOS for durable execution across two replicas. The setup includes a FastAPI application serving Counter and Greeter (human-in-the-loop) workflows, with distributed tracing exported via OpenTelemetry to Arize Phoenix and Jaeger. It provides a Tiltfile and Kustomize manifests to easily spin up the entire stack (Postgres, Phoenix, Jaeger, OTel Collector) on a local kind cluster.

examples/k8s-otel · high confidence

Developers can now spin up a complete local Kubernetes environment using Tilt, which automatically provisions the llama-agents control plane, a SeaweedFS S3-compatible object store, and a Prometheus monitoring stack. The setup includes a cron job to prune containerd images in Kind to prevent storage growth, a Python script to convert .env files into Kubernetes secrets, and Helm values configured for hot-reload and debug logging.

operator/tilt · high confidence

The development CLI now includes four new commands to streamline local development workflows. The \changeset-version\ command applies changeset version bumps and synchronizes Python package versions with JavaScript versions, while \changeset-publish\ allows for local planning and publishing of all workspace packages. A new \dev test\ command (pytest\_cmd) runs tests across packages with parallel execution support and displays detailed test counts and failure summaries. Additionally, the \sync-skills\ command symlinks agent skills from the checked-in \.agents/skills\ directory into the \.claude/skills\ directory for use with Claude Code.

_src/dev\cli/commands · high confidence

Added a new example script, \resource\_nodes\_example.py\, that illustrates how to visualize workflow steps dependent on injected resources (such as database, cache, and LLM clients) in both Mermaid and Pyvis formats. This example shows users how resource dependencies are rendered as distinct nodes in the generated workflow diagrams, providing a concrete reference for implementing and debugging resource-aware workflows.

examples/visualization · high confidence

The \examples\ directory now contains a curated collection of runnable Jupyter notebooks and code samples demonstrating how to build, serve, and deploy agent workflows using \llama-index-workflows\ and \llama-agents\. The new \README.md\ serves as an index, guiding users through a progression of examples including a feature walkthrough, function-calling agents, document processing pipelines, durable workflows with state persistence, eval-driven prompt refinement, and advanced patterns like streaming internal events and vector database state management.

examples · high confidence

Added a new notebook example in the \examples/document\_agents\ directory that demonstrates a finance team assistant agent. This agent uses LlamaExtract and LlamaClassify to triage incoming emails with attachments (invoices or expenses), extract specific data fields, and simulate appropriate responses based on the classification.

_examples/document\agents · high confidence

The \llama-agents-server\ package introduces a new \WorkflowServer\ that exposes workflows as a REST API with endpoints for running workflows, streaming events, and sending human-in-the-loop input. It includes a built-in debugging UI, configurable persistence backends (memory, SQLite, Postgres), and supports durable workflows with automatic state recovery and idle-release. The server also provides structured error responses, SSE heartbeats to prevent idle connection drops, and optional context API support for submitting saved state.

_packages/llama-agents-server/src/llama\agents/server · high confidence

Developers can now spin up a local Kubernetes cluster (kind or Docker Desktop) and run the operator with live-reload via Tilt. This includes a new dev.py CLI script to manage the cluster lifecycle, a Tiltfile that builds and injects the operator and control-plane images, and a Makefile with targets for linting, testing, and Helm chart validation.

operator · high confidence

The examples/observability directory now includes a README and four new Jupyter notebooks demonstrating how to instrument LlamaIndex workflows. These examples show how to use native LlamaIndex instrumentation with OpenTelemetry to create custom spans and events, how to export traces to third-party platforms like Arize Phoenix and Langfuse, and how to integrate the dispatcher context (including run IDs) into both structlog and standard library logging for structured, correlated log output.

examples/observability · high confidence

The server now supports persistent workflow state storage via two new backends: a Postgres implementation using asyncpg with LISTEN/NOTIFY for real-time event streaming, and a LlamaCloud Agent Data API client with automatic retries for transient read failures. State is now keyed by both run ID and namespace, allowing multiple state records per run, and the system includes SQL migration utilities to manage schema versions automatically.

_packages/llama-agents-server/src/llama\_agents/server/\store · high confidence

Added \scripts/process\_manifests.py\ to automate the generation of Helm templates from kubebuilder outputs, specifically handling RBAC rules (splitting leader-election leases into the release namespace when apps and release namespaces differ) and copying CRD files to the appropriate chart directories. Also added \scripts/sync-docs-to-developer-hub.sh\ to sync markdown documentation and build API references into a developer hub repository, ensuring paths are resolved absolutely before changing directories.

scripts · high confidence

Added \examples/server\ with documentation and runnable code demonstrating how to use \WorkflowServer\ to expose workflows as HTTP services. The examples show how to run the server standalone or mount it as a sub-application within an existing FastAPI app, and include notebooks and scripts illustrating event streaming via Server-Sent Events (SSE) for real-time progress updates.

examples/server · high confidence

The repository has been initialized as a monorepo for the LlamaAgents project, establishing the foundational structure and development tooling. This includes a \uv.lock\ file for Python dependency management across multiple packages (such as \llama-index-workflows\, \llama-agents-server\, and \llamactl\), a \pnpm-workspace.yaml\ for JavaScript/TypeScript tooling, and configuration files for pre-commit hooks (Ruff, basedpyright, ty) and code formatting. The project also introduces new documentation guides (\AGENTS.md\, \CLAUDE.md\) for development workflows and removes legacy build artifacts like \BUILD\ and \\_\init\\_.py\ files that were part of the previous \llama\_index.core.workflow\ structure.

(repo-wide) · high confidence

The \llama\_agents\ package is now the primary library, with a new \llama\_deploy\ namespace that automatically redirects to it for backward compatibility. This core library provides the foundational components for deployment management, including Pydantic schemas for deployments, backups, and projects, as well as async HTTP clients for interacting with the control plane. It also introduces a new \appserver\_version\ field to replace the deprecated \llama\_deploy\_version\, while maintaining support for the old name in input data. The package includes utilities for validating git URLs (preventing SSRF and dangerous schemes), managing deployment configurations from TOML/YAML, and handling SSL/TLS verification via system truststores.

packages/llama-agents-core/src · high confidence

The SQLite backend for the agents server has been restructured to support robust schema evolution and multi-namespace state isolation. A new migration system (migrate.py) automatically applies versioned SQL changes, including a new migration that adds a \namespace\ dimension to the \workflow\_state\ table, allowing workflows to store and retrieve state scoped to specific namespaces rather than just a global run ID. The implementation also introduces a \single\_connection\ mode that uses the \unix-none\ VFS to bypass file locking, improving reliability for single-process scenarios, and enables WAL journal mode for better concurrent read/write performance.

_packages/llama-agents-server/src/llama\_agents/server/\store/sqlite · high confidence

The static entry point for the workflow debugger has been updated to load version 0.2.42 of the @llamaindex/workflow-debugger library from the jsDelivr CDN, replacing the previous version references in the HTML file.

_packages/llama-agents-server/src/llama\agents/server/static · high confidence

The workflow utility module now provides improved graph visualization and representation capabilities. It supports rendering nested workflows and includes specific node types for resources and resource configurations in the workflow graph. Visualization outputs (Pyvis and Mermaid) have been updated to distinguish these new node types with specific colors and shapes, and Mermaid execution step IDs are now sanitized to handle slashes correctly. Additionally, workflow names are included in the workflow graph export, and the system reads workflows from globals rather than sys modules to support better runtime plugin architecture.

packages/llama-index-utils-workflow/src · high confidence

The \llama-index-workflows\ package has been reorganized under the \llama\_agents\ namespace, with the core workflow logic now located in \src/workflows/\ and a compatibility shim in \src/llama\_agents/workflows/\ that lazily redirects imports to the new location. This change introduces a new serialization format (v2) for workflow context state, which includes detailed retry information, waiter state, and collection stream scope paths to support more robust persistence and recovery. Additionally, the package now supports subclass-aware event routing, allowing steps to accept events that are subclasses of their declared types, and introduces a \Collect\ marker with \All\ and \Take\ cardinalities to control how fan-in steps consume events from collection streams.

packages/llama-index-workflows/src · high confidence

The llamactl CLI has been reorganized into a new modular structure with dedicated command groups for agents, deployments, authentication, environments, and development utilities. A new shell completion system has been added, supporting bash, zsh, and fish with auto-installation capabilities. The authentication flow now supports both API key and OIDC browser login with profile management. Deployment management includes YAML-based apply functionality with environment variable resolution and error annotation. The CLI now provides better error handling for OIDC configuration issues and supports non-interactive authentication modes.

packages/llamactl/src · high confidence

Added DBOS integration test fixtures for workflow execution and server simulation; Added comprehensive test suite for llamactl CLI; Added comprehensive test suite for workflow context state management and serialization; Added integration tests for DBOS workflow execution and resilience; Added runtime test suite for workflow execution and state management; Added test coverage for core client, deployment, and utility modules; Added tests for WorkflowClient and workflow execution; Added tests for backup, code repo, deployment, and build subsystems; Added tests for protocol event serialization and deserialization; Added tests for the dev CLI; Added tests for workflow visualization and resource handling; Expanded test coverage for llama-agents-server runtime and API components; Initial test suite for llama-agents-agentcore; Initial test suite for the Llama Agents App Server; Integration test suite for llama-agents workflows and stores; New integration test infrastructure for llama-agents; Operator controller tests for namespace isolation, pod classification, and rollout lifecycle.

This change introduces the foundational structure for the LlamaAgents monorepo, establishing a unified workspace that coordinates multiple Python and TypeScript packages. It adds \pyproject.toml\ and \package.json\ manifests for core components including \llama-index-workflows\, \llama-agents-server\, \llama-agents-client\, \llama-agents-core\, \llama-agents-appserver\, \llama-agents-control-plane\, \llamactl\, and the Kubernetes operator. The configuration standardizes the build system to \uv\ (using \uv\_build\) for Python packages and \pnpm\ for the workspace, while defining explicit dependency ranges (e.g., \llama-index-workflows\>=2.21.0\ for the server) and dev tooling like \pytest\, \ruff\, and \basedpyright\. It also includes the Go module definition for the operator and Helm chart metadata, effectively setting up the dependency graph and versioning strategy for the entire suite.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 66 → 65 (-1.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 79 → 86 (+7.2)
• Architecture 98 → 99 (+1.3)
• Maturity 73 → 73 (+0.3)
• Readiness 65 → 59 (-5.9)
• Security 64 → 65 (+0.6)
• Accessibility 65 → 68 (+3.6)

• Boundary-crossing change coupling: server.py ↔ init.py (packages/llama-agents-server/src/llama_agents/server/server.py)
• Change coupling: commands.py ↔ results.py (packages/llama-index-workflows/src/workflows/runtime/types/commands.py)
• Change coupling: context_types.py ↔ results.py (packages/llama-index-workflows/src/workflows/context/context_types.py)
• Change coupling: memory_workflow_store.py ↔ sqlite_workflow_store.py (packages/llama-agents-server/src/llama_agents/server/_store/memory_workflow_store.py)
• Change coupling: step_function.py ↔ ticks.py (packages/llama-index-workflows/src/workflows/runtime/types/step_function.py)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (11 lines × 2) (packages/llama-index-workflows/src/workflows/runtime/types/internal_state.py)
• Duplicated block (11 lines × 2) (packages/llamactl/src/llama_agents/cli/commands/deployment.py)
• Duplicated block (11 lines × 2) (packages/llamactl/src/llama_agents/cli/commands/pkg.py)
• Duplicated block (13 lines × 2) (packages/llama-agents-appserver/src/llama_agents/appserver/routers/deployments.py)
• Duplicated block (13 lines × 2) (packages/llama-index-workflows/src/workflows/representation/build.py)
• Duplicated block (14 lines × 2) (packages/llama-agents-server/src/llama_agents/server/_store/postgres_workflow_store.py)
• Duplicated block (14 lines × 2) (packages/llama-index-workflows/src/workflows/representation/validate.py)
• Duplicated block (14 lines × 2) (packages/llamactl/src/llama_agents/cli/auth/client.py)
• Duplicated block (15 lines × 2) (packages/llama-index-utils-workflow/src/llama_index/utils/workflow/init.py)
• Duplicated block (16 lines × 2) (packages/llama-agents-client/src/llama_agents/client/client.py)
• Duplicated block (18 lines × 2) (packages/llama-index-utils-workflow/src/llama_index/utils/workflow/init.py)
• Duplicated block (53 lines × 2) (packages/llama-agents-server/src/llama_agents/server/_api.py)
• Duplicated block (6 lines × 2) (packages/llama-agents-core/src/llama_agents/core/schema/deployments.py)
• …and 48 more

• Banned license: psycopg
• Critical CVE: [GHSA redacted] (uv.lock)
• Critical CVE: [GHSA redacted] (uv.lock)
• Critical CVE: [GHSA redacted] (uv.lock)
• Documentation: no installation or build instructions (README.md)
• Duplicate intent with different signatures. 'previous_tag' takes a pre-fetched list of tags, while 'find_previous_tag' takes a repo and prefix and likely fetches tags internally. This creates a split in responsibility: one is a pure utility, the other is a higher-level API. This can lead to confusion about which to use.
• Duplicated block (12 lines × 2) (packages/llamactl/src/llama_agents/cli/commands/pkg.py)
• Duplicated block (13 lines × 2) (packages/llama-agents-appserver/src/llama_agents/appserver/routers/deployments.py)
• Duplicated block (13 lines × 2) (packages/llamactl/src/llama_agents/cli/commands/deployment.py)
• Duplicated block (14 lines × 2) (packages/llama-index-workflows/src/workflows/representation/validate.py)
• Duplicated block (14 lines × 2) (packages/llama-index-workflows/src/workflows/runtime/types/internal_state.py)
• Duplicated block (14–16 lines × 2) (packages/llamactl/src/llama_agents/cli/auth/client.py)
• Duplicated block (16 lines × 2) (packages/llama-index-workflows/src/workflows/representation/build.py)
• Duplicated block (18 lines × 2) (packages/llama-agents-server/src/llama_agents/server/_store/postgres_workflow_store.py)
• Duplicated block (22–23 lines × 2) (packages/llama-index-utils-workflow/src/llama_index/utils/workflow/init.py)
• Duplicated block (25 lines × 2) (packages/llama-agents-client/src/llama_agents/client/client.py)
• Duplicated block (35 lines × 2) (packages/llama-index-utils-workflow/src/llama_index/utils/workflow/init.py)
• Duplicated block (5 lines × 2) (packages/llama-agents-dbos/src/llama_agents/dbos/journal/crud.py)
• Duplicated block (5 lines × 3) (packages/llama-agents-server/src/llama_agents/server/_store/memory_workflow_store.py)
• Duplicated block (61–64 lines × 2) (packages/llama-agents-server/src/llama_agents/server/_api.py)
• …and 210 more

• 27 commits — 25 feature/other, 2 fixes

• packages/llama-index-workflows — 9 commits
• packages/llama-agents-client — 4 commits
• packages/llama-agents-appserver — 3 commits
• packages/llama-agents-server — 3 commits
• .changeset/update-debugger-assets.md — 2 commits
• packages/llama-agents-dbos — 2 commits
• .changeset/appserver-serializer-configuration.md — 1 commit
• charts/llama-agents — 1 commit
• docs/src — 1 commit
• operator/internal — 1 commit

• fix: fix(retry): correct attempt-index off-by-one between wait strategies (#734)
• fix: fix: use immutable defaults for read-only sequences (#749)
• change: Add handler completion polling to WorkflowClient (#737)
• change: Add typed workflow introspection to WorkflowClient (#739)
• change: Clarify serializer release notes by package (#759)
• change: Copy state instead of writing through on an unrebuildable set path (#746)
• change: Decode API events and stored results from workflow declarations (#756)
• change: Disable service links on operator-managed pods (#751)
• change: Enforce workflow concurrency through DBOS worker queues (#732)
• change: Keep FastAPI instrumentation dependencies compatible (#731)
• change: Rebuild only the written path in ctx.store.set (#744)
• change: Reject concurrent reuse of active handler IDs (#738)
• change: Remove Agent Builder from LlamaAgents docs (#730)
• change: Resolve JSON types from registered classes (#754)
• change: Restore server workflow state from declared types by default (#757)
• change: Share excluded pydantic fields by reference when copying state for an edit (#743)
• change: Support unhashable workflows in serializer caching (#762)
• change: Update debugger assets (#729)
• change: Update debugger assets (#741)
• change: Use the configured serializer across workflow persistence (#755)
• …and 7 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

run-llama/llama-agents was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.