Source: openai/openai-cookbook
The blog post details the functionality of triggering a Workspace Agent via an API, allowing teams to initiate automated workflows stored within ChatGPT. Key highlights include the use of asynchronous API calls to initiate these workflows, with the agent acting on predefined instructions, app permissions, and approval settings. The article outlines the necessary prerequisites for setting up, including enabling Workspace Agents and creating an API channel with a trigger ID.
Readers are guided through steps to build their setup, including crafting agent instructions, connecting output destinations, and configuring the live API call. The process involves crafting source events, sending them to the agent, and managing responses. The ability to manage outputs effectively through proper app authentication and agent settings is emphasized, which ensures successful execution of the automated tasks.
]]>Source: openai/openai-cookbook
The blog post introduces SchemaFlow, a structured framework utilizing OpenAI’s Agents SDK to facilitate AI-assisted database change workflows. It outlines a retail-oriented use case focused on a database schema change, providing an adaptable architectural pattern suitable for various industries. The process begins with a natural-language database request, converting it to structured JSON and conducting impact analysis. Key features include a staged workflow with distinct responsibilities for parsing, risk analysis, rollout planning, and SQL generation; real-time validation checks; and a comprehensive audit trail for each step. The final outcome is a consolidated JSON artifact containing the parsed request, impact analysis, SQL script, and validation results. SchemaFlow aims to enhance traceability, reduce risks related to database changes, and improve communication among teams, positioning itself as a vital tool for complex data-driven environments.
]]>The blog posts collectively highlight several key trends and announcements in automated agent workflows, integration best practices, and product advancements:
Integration of Sentry Triage with Claude Managed Agents:
Multiple posts describe the launch of a robust integration between Sentry and Claude Managed Agents, enabling automated, scheduled triage and reporting of Sentry issues. These integrations emphasize secure authentication (via Vault credentials and scoped tokens), operational best practices (including allowlist configurations for networking and credentials), and detailed setup guides for deployment and maintenance. Flexibility and extensibility are supported through modular scripts (setup_agent.py, deploy.py), CLI integrations, memory tracking, and third-party notifications (e.g., Slack).
Agent Workflow Patterns and Tooling:
The posts introduce reference implementations and orchestration patterns for building effective agents. Practical agent design is supported through ready-to-use templates for common workflows (e.g., prompt chaining, routing, evaluator-optimizer models, and asynchronous orchestration). These workflows leverage the Anthropic SDK and tools like asyncio, with guidance for developer customization, standardized communication (via message hubs), and orchestration mechanics for both static and dynamic agent teams.
Claude Fable 5 Release, Safety Protocols, and Billing Changes:
Claude Fable 5 is announced with advanced capabilities and significant safety controls, particularly in high-risk domains like cybersecurity and life sciences. Automated safeguards detect and block requests in these domains, triggering an automatic fallback to the Opus 4.8 model, configurable server-side or client-side. New billing practices minimize user costs during classifier-blocked requests, including not charging for blocked input tokens and introducing fallback credit tokens for retries. Comprehensive fallback and billing configuration strategies are provided to maximize reliability and cost-efficiency.
Overall, these updates showcase a coordinated push toward safer, more extensible, and cost-effective agent systems, emphasizing secure integrations, modular workflow design, and automated safeguards against misuse in sensitive domains.
Source: anthropics/claude-cookbooks
The blog post discusses the integration of Sentry triage with Claude Managed Agents, outlining the process for setup and deployment. It emphasizes a structured approach to implementation, starting with invoking the /claude-api to access the Managed Agents API reference. Users are guided to follow the checklist in ./skill.md, which covers critical elements such as host allowlists and debugging techniques. After establishing the base schedule, users can extend functionality by modifying setup_agent.py or deploy.py, allowing for features like report delivery to Slack, additional CLI integrations, and memory store tracking for issue history. The post provides commands for provisioning, scheduling, smoke-testing, and making updates to the agent configuration.
Source: anthropics/claude-cookbooks
The blog post announces the integration of Sentry and Claude Managed Agents, facilitating automated triage reporting of Sentry issues. A Managed Agent, scheduled via cron, fetches the last 24 hours of issues using sentry-cli and generates a prioritized report without a host process. The Sentry token is securely handled as a vault credential, ensuring that the model does not access the secret directly.
The quickstart guide offers step-by-step instructions for setting up the integration, including authentication using an API key or CLI login. Key files related to the setup, such as setup_agent.py and deploy.py, are specified for various configurations, including one-time setups and manual trigger execution. The integration requires the anthropic SDK version 0.109.0 or higher.
Source: anthropics/claude-cookbooks
The blog post provides comprehensive guidance on setting up scheduled Sentry triage using Vault environment variable credentials, highlighting key operational details not explicitly mentioned in the documentation. It explains the secure management of Sentry authentication tokens, emphasizing that real tokens are not stored in containers, only opaque placeholders are utilized. The article delineates the roles of two allowlists: one for networking permissions and another for credential substitution, which must include both sentry.io and *.sentry.io. Additionally, it outlines deployment practices, including how to manage agent versions, scheduling, and potential issues like deployment pauses due to failures. The post concludes with a setup checklist and troubleshooting tips to ensure smooth operation and integration with Sentry, suggesting that scoping tokens to specific projects can enhance security.
Source: anthropics/claude-cookbooks
The “Building Effective Agents Cookbook” blog post introduces a reference implementation for the related research by Erik Schluntz and Barry Zhang. It presents minimal implementations of common agent workflows, categorized into basic building blocks such as prompt chaining, routing, and multi-LLM parallelization, as well as advanced workflows like orchestrator-subagents and evaluator-optimizer models. The post emphasizes practical application by providing Jupyter notebooks containing detailed examples for various workflows, including basic workflows, the evaluator-optimizer workflow, the orchestrator-workers workflow, and asynchronous multi-agent orchestration.
Source: anthropics/claude-cookbooks
The blog post outlines the multi-agent orchestration patterns in the Claude Opus 4.8 system, specifically focusing on fixed N-agent teams and asynchronous subagents. It details a framework utilizing the Anthropic Python SDK and asyncio, enabling developers to implement their own tools and tasks in a structured messaging environment.
Key features include:
The post encourages further customization by integrating user-specific domain tools and provides guidance on orchestration mechanics.
Source: anthropics/claude-cookbooks
The blog post announces Claude Fable 5’s deployment, highlighting its advanced capabilities alongside crucial safety measures. Due to potential misuse in cybersecurity and life sciences, the model includes automated safeguards that limit performance in these areas, resulting in a fallback to Opus 4.8 when such requests are made. Users are recommended to set up server-side or client-side fallback options to manage these restrictions effectively.
Additionally, updates to billing practices minimize costs, particularly during fallbacks, with input tokens for classifier-blocked requests not incurring charges. Specific tech details on classifier blocks, fallback configurations, and associated billing mechanisms are discussed. Overall, the release aims to balance powerful capabilities with strict safety protocols.
Source: anthropics/claude-cookbooks
Claude Fable 5 introduces enhanced capabilities across various domains, including cybersecurity and life sciences, while implementing robust safeguards to prevent misuse. To enhance user experience, automated safety checks will monitor requests and automatically fallback to Opus 4.8 for topics related to biology and cybersecurity.
API users are advised to configure this fallback mechanism through either server-side or client-side options. Billing adjustments have been made to mitigate costs associated with fallback situations, such that input tokens are not charged during classifier blocks. Furthermore, Fable 5 requests that are blocked will now incorporate a fallback credit token to facilitate better billing rates when retrying with Opus 4.8.
The post outlines detailed strategies for configuring fallbacks, implications for streaming, and new billing protocols for enhanced efficiency and cost-effectiveness.
]]>Source: openai/openai-cookbook
The blog post introduces SchemaFlow, a comprehensive AI-assisted workflow designed for database change impact analysis, SQL generation, and implementation guardrails using the OpenAI Agents SDK. It outlines an end-to-end process focusing on interpreting natural-language change requests, with a specific example surrounding retail customer data. Key features include parsing requests into structured JSON, conducting impact analysis, creating rollout plans, and generating SQL statements across data platforms while validating outputs at each stage to minimize risks. This structured approach ensures traceability, efficient collaboration among team members, and the production of reusable artifacts. The adaptable workflow pattern can be applied beyond retail to various industries requiring structured data management and operational analysis. Overall, SchemaFlow aims to streamline database changes, enhancing both accuracy and safety in data engineering tasks.
]]>Source: openai/openai-cookbook
OpenAI is discontinuing its Evals product and recommends transitioning to Promptfoo for evaluation workflows. Promptfoo is an open-source CLI and library that allows users to evaluate and red-team AI applications with a more flexible, code-oriented workflow. It enables local or CI-based executions, while OpenAI Evals managed evaluations through its platform dashboard.
Users can export evaluations from OpenAI Evals into runnable Promptfoo configurations, preserving key elements such as test data and scoring criteria. However, Promptfoo setup may require additional manual configurations for certain evaluations and grading processes. Historical evaluation results can be imported into Promptfoo for ongoing reference.
The migration aims to enhance user experience by integrating evaluations with application code and adapting testing as needs evolve. Users are encouraged to install Promptfoo, configure their evaluations, and explore its capabilities for comprehensive testing and development workflows.
]]>openai.gpt-5.4 within AWS infrastructure.
Source: openai/openai-cookbook
The blog post introduces the integration of OpenAI models into Amazon Bedrock, featuring a Responses API designed for production workflows that include text generation, structured outputs, and state management. It provides a detailed cookbook for creating a support assistant workflow for a fictional retailer, BrightCart, addressing delayed and damaged-order requests. Key features include configuration of the Bedrock-hosted OpenAI model, verification of the Responses endpoint, and capabilities for sending requests using both the OpenAI SDK and raw HTTPS requests. The guide covers generating schema-constrained JSON, using application-managed tools, sending direct file inputs, and implementing prompt caching and cleanup routines. Prerequisites include Python 3.9 or newer and an OpenAI bearer token for authentication. The default model used in examples is openai.gpt-5.4, hosted in the us-west-2 region.
Source: openai/openai-cookbook
The blog post introduces a practical example of building a semantic search workflow utilizing OpenAI embeddings, LangChain’s Oracle vector store integration, and Oracle AI Database for vector search. Key announcements include the seamless integration of these components, highlighting their individual strengths: OpenAI embeddings transform text into meaningful vectors, LangChain provides a user-friendly framework for vector storage and retrieval, and Oracle AI Database efficiently manages embeddings alongside traditional application data.
Developers can expect to learn how to connect to Oracle, configure embeddings, and perform vector similarity searches. The tutorial is aimed at simplifying the setup for semantic retrieval applications and suggests a straightforward path for extending this workflow into larger projects, such as Retrieval-Augmented Generation (RAG) applications.
Source: openai/openai-cookbook
The blog post details a guide on constructing a semantic search workflow utilizing OpenAI embeddings, LangChain, and the Oracle AI Database. Key components include:
The workflow demonstrates embedding text documents, querying with natural language, and retrieving the most relevant documents. It supports applications like retrieval-augmented generation (RAG) and internal semantic searches without needing a separate vector database. Requirements include Python 3.10+, OpenAI API access, and an Oracle database environment with vector search capabilities. The guide provides code snippets for setup, querying, and managing embeddings. Overall, it outlines a robust structure to enhance search functionalities within Oracle’s ecosystem.
Source: anthropics/claude-cookbooks
The blog post outlines three deployment tiers for a research agent developed in a Python notebook, aiming to make it accessible beyond local usage.
The agent remains consistent across tiers, requiring only configuration changes. Production considerations include observability, health checks, and enhanced session persistence. The post emphasizes choosing a tier based on workload needs and scalability requirements.
]]>Across all deployment methods, strong emphasis is placed on secure configuration, consistent API interface contracts, observability, and proper file structuring. Notable trends include the use of persistent session storage where possible, enhancements to deployment automation and monitoring, and practical cost considerations. Collectively, the announcements guide developers through a flexible ecosystem for both experimentation and scalable, robust production deployments of AI agents.
Source: anthropics/claude-cookbooks
The blog post details the deployment of a research agent through three tiers: Docker, Modal, and Kubernetes. Each tier serves different needs, from local development to multi-tenant production environments.
Tier 1 - Docker: Ideal for internal tools and single-tenant applications, allowing basic container deployment with manual session management.
Tier 2 - Modal: Offers serverless hosting, providing a public HTTPS URL and automatic scaling without infrastructure management. It requires minimal setup but has limited authentication.
Tier 3 - Kubernetes: Best for regulated environments, enabling pod-per-session isolation and an authenticating gateway for tenant-scoped sessions. It involves more complex infrastructure management.
The notebook includes a deployment guide, cost estimates, and insights on using the Agent SDK for customer-facing products and internal tools. A production-ready configuration involves observability, liveness checks, and session persistence strategies.
Source: anthropics/claude-cookbooks
The blog post details the deployment options for a research agent through three tiers: local Docker, Modal, and Kubernetes. All tiers utilize the same agent image and HTTP interface, differing only in deployment mechanisms. The article provides an interface contract outlining essential API endpoints, including the health check and message session management, along with security precautions to avoid exposing the service directly to the internet. A structured directory layout for organizing files related to hosting the agent is presented, highlighting the shared Dockerfile and server implementation. The post emphasizes proper configuration requirements, including the necessary environment variables for operation and guidelines for building the Docker container from the parent directory. For comprehensive instructions, readers are encouraged to refer to the linked notebooks.
Source: anthropics/claude-cookbooks
The blog post introduces two operational modes for running the shared image of the Claude Agent SDK locally using Docker: Ephemeral and Hybrid.
In the Ephemeral mode, the SDK is executed as a one-off process, ideal for batch processing and single analyses, which does not require maintaining the session after completion.
In the Hybrid mode, it runs a FastAPI server, allowing persistent sessions that maintain conversation context across container restarts by mounting session data. This enables users to have ongoing dialogues with the agent, with session data stored locally. The post provides command-line examples for both modes, illustrating the setup and interaction with the SDK.
Source: anthropics/claude-cookbooks
The blog post outlines the implementation of a Kubernetes hosting tier (Tier 3) for running an agent in isolated pods per session, enhancing security through network-level controls. Each user session is assigned its own pod managed by a gateway, which interacts with the Kubernetes API and utilizes Redis for session-pod mapping. Key components include an egress proxy that ensures agent pods can only access the Anthropic API, and a standby pool that pre-warms pods for faster session initialization.
The guide provides prerequisites for deployment using local Kubernetes clusters and discusses how to configure and run the setup, including tenant management and egress lockdown verification. Additionally, it notes limitations, such as the absence of a real identity provider and durable session storage. The post serves as a comprehensive guide for teams requiring customized, secure deployments in controlled environments.
Source: anthropics/claude-cookbooks
The blog post introduces the use of Modal for running the same Dockerfile image through modal.Sandbox, enabling developers to deploy applications without managing infrastructure. Key features include public HTTPS URLs, scale-to-zero functionality, and easy setup with prerequisites such as installing the Modal package and creating secrets. Deployment is accomplished by executing a script that builds the Docker image and starts a service, providing a public URL for interaction.
Session persistence is achieved through a mounted volume, though concurrent writes may require employing a SessionStore for reliability. The sandbox runs until a specified timeout, and it’s recommended to monitor server health manually. Finally, teardown instructions ensure that sandboxes and associated resources are stopped to avoid unnecessary charges.
Source: openai/openai-cookbook
The blog post discusses the migration from the Claude Agent SDK to the updated OpenAI Agents SDK. The new SDK offers a model-native harness for building agents that efficiently coordinate across various tools and environments. Key architectural changes include a separation of the agent harness from the compute environment, enhancing safety and operability.
The post outlines essential migration steps, such as restructuring instruction and skill files, modifying lifecycle callbacks, and clarifying agent ownership. It emphasizes a strategic approach to maintaining the original app behavior while improving execution and safety boundaries.
A sample flight-booking assistant is used to illustrate both the baseline implementation in Claude and the new OpenAI model, highlighting the transition from Claude’s tightly integrated environment to a more modular architecture in the OpenAI Agents SDK.
]]>Recent blog posts emphasize new tools and frameworks for macro-level evaluation of multi-agent systems—particularly in domains like electric vehicle order processing. The main trends include the introduction of a self-contained, offline OpenAI Cookbook notebook using synthetic data, and a structured macro-evaluation workflow that pairs lower-level agent assessments with systemic, pattern-based analysis. These tools enable comprehensive diagnosis of recurring agent behaviors and failures, equip users—both technical and business stakeholders—with actionable insights, and streamline evaluation with practical guides and sample code. Together, these advancements make it easier to analyze, diagnose, and optimize complex agentic workflows through reproducible, standalone resources.
Source: openai/openai-cookbook
The blog post introduces a self-contained OpenAI Cookbook notebook designed for macro-level evaluation of a traced multi-agent system, requiring no OpenAI API key and operating entirely offline with synthetic data. It details the step-by-step process to analyze multi-agent system runs, revealing recurring behavior patterns and enabling in-depth diagnosis of specific patterns. Key components of the provided dataset include metadata for 1,000 simulated orders and lower-level evaluation labels. The notebook is located in the designated repository path and requires the execution of a script to run. Users are guided on which files to upload and are advised on best practices for managing generated artifacts. The post emphasizes that the notebook serves as a standalone tool, referencing OpenAI’s official documentation for further development and orchestration guidance.
Source: openai/openai-cookbook
The blog post discusses a macro-evaluation (macro-eval) workflow for multi-agent systems, particularly in scenarios like electric vehicle order processing. It highlights how failures in agentic systems can be intricate and require a comprehensive analysis of multiple trace behaviors. The workflow includes generating agent run traces, conducting lower-level evaluations, and identifying recurring patterns to enhance decision-making processes.
Key features include:
This process aims to optimize performances and responses within agentic systems by collaborating effectively across specialized agent roles.
]]>