# Useful but Little-Known Features of OpenAI Agent SDK 🌍 Want to stream progress in real time while a nested agent tool is running? With the `on_stream` callback, you can receive events from child agent executions in real time on the parent side. 📌 Title: Streaming Nested Agent Runs 🔗 URL: 🧩 Overview When converting an agent to a tool with `as_tool()`, you can set a callback function on the `on_stream` parameter. This callback receives `AgentToolStreamEvent` and can process events in real time during child agent execution, including `raw_response_event` and `run_item_stream_event`. The event types mirror the standard streaming format, so you can reuse existing streaming handlers. 🛠 How to use it ```python from agents import Agent, Runner research_agent = Agent( name="researcher", instructions="Research the topic in detail", ) # Streaming callback async def handle_stream(event): # raw_response_event: model responses # run_item_stream_event: tool calls, etc. if hasattr(event, 'data'): print(f"[Researching] {") parent = Agent( name="coordinator", tools=[ research_agent.as_tool( tool_name="research", tool_description="Research a topic", on_stream=handle_stream, ), ], ) # Streamed execution async for event in "Research the latest AI trends"): print(event) ``` 🏗 Building it into production ・Display child agent processing progress in the UI in real time so users never feel stuck waiting ・Use `raw_response_event` to incrementally display generated text ・Log tool execution status via `run_item_stream_event` ・Reuse existing streaming UI components as-is 💡 Use cases 🖥 Real-time UI display of multi-agent processing progress 📝 Typewriter-style incremental display of child agent responses 🔍 Visualizing a research agent's search and analysis process 📊 Providing users with intermediate feedback during long-running tasks ⚠️ Watch out The `on_stream` callback runs within the child agent's execution thread, so heavy processing will impact overall agent performance. Keep event handlers lightweight and consider offloading to an async queue if needed. Add guard clauses to ignore unknown event types for forward compatibility. ✨ With streaming, give users a transparent "see inside" experience for multi-agent workflows. #OpenAIAgentSDK# #AIAgent#

AI self-evolution is undoubtedly the ultimate core of next-gen AI—and true evolution is fundamentally built on Long-Term Memory. 🧠 At EverMind, we believe every AI of the future must have long-term memory. If you want to build an AI that continuously adapts and unlocks a massive data flywheel, you need EverOS. ♾️ The update we’ve been polishing for ages is FINALLY live! 🚀 It's way more than just a product update—Methods, Benchmarks, Usecases, and a fresh site are all here. Here’s the breakdown: 👇 1️⃣ EverMemOS ➡️ EverOS: The ultimate one-stop shop. EverOS now empowers your Agents with self-evolution capabilities—just like Hermes Agent. Plus, we’ve added full multi-modal support. Use our Methods to customize Usecases into your own Agents, then benchmark to optimize them. It's the absolute all-in-one king. 👑 2️⃣ EvoAgentBench is LIVE & Open-Source: The perfect tool to test your custom Claude Code, OpenClaw, Hermes, or any Agent you throw at it. 📊 3️⃣ Brand New Website: Aesthetics matter. The new vibe, colors, and interactive experiences are absolutely off the charts. 🎨🔥 Dive in here: #EverOS# #AI# #AgentTools# #Harness# @Memory #OpenClaw# #Hermes# #ClaudeCode#

agent tools need an OpenRouter layer this could be a HUGE infrastructure opportunity in AI OpenRouter gave developers one place to discover models, call them through the same interface, compare prices and route requests by price, speed and availability one campaign agent might use Firecrawl for research, Stripe for payments, HubSpot for CRM and Slack for communication connecting those providers directly means managing separate accounts, credentials, billing, permissions and tool formats (mega headache) the opportunity is one agent-tool router that manages how agents discover and run actions across those providers: > describe the outcome > discover the right provider > connect the correct company account > see the price and permissions > run the work and verify the result > retry, send it for human review or fall back to another provider this goes beyond an MCP directory. MCPs gives agents a common way to discover and call tools, while the agent-tool router still needs provider success rates, prices, permissions and verified outcomes we are moving from APIs that expose individual product actions toward outcome endpoints an outcome endpoint lets an agent request a finished job while the provider handles the planning, execution, validation and delivery (basically: give the agent the job, get back the finished result + receipt) an agent needs a small set of jobs it can request: > research this market > reconcile this account > launch this campaign > resolve this support ticket > produce this report > update this forecast Firecrawl lets an agent request a research job, while Parallel takes a research task and returns a synthesis with sources Composio and Pipedream aggregate large tool catalogs and handle parts of discovery, account authentication and execution. the official MCP Registry provides shared metadata for public tool servers. x402 is a pay-per-call protocol that lets agents purchase access to compatible endpoints the complete agent-tool router is still missing (we have most of the pieces, nobody seems to own the full route yet) this is where it gets messy: tools are harder to route than models. a model request usually returns text, media or embeddings, while an agent tool can publish a post, refund a payment, contact a customer, delete data or change the state of a company account so the router has to know a lot more than "which endpoint is cheapest": > per-user identity and permissions > human sign-offs for spend and external actions > protection against duplicate writes, plus a way to undo partial changes > logs, receipts and checks that confirm the outcome > routing based on price, speed, reliability and quality > fallback only when providers can safely produce the same result one connection should handle discovery, credentials, approval and access rules, billing and execution, while every agent receives only the account access and actions required for its job for a marketing agent, that could mean selecting a research provider, connecting the client workspace, showing the expected spend, waiting for sign-off before publishing, then returning the live links and receipts to the campaign brain, the files holding the campaign plan and results people use human interfaces to configure the system, approve sensitive actions, monitor work and handle exceptions. agents call outcome endpoints to run approved jobs the open problem is proving the selected provider finished the job before the router accepts the result, retries or safely falls back

I’m really proud of these agent tools I’m building. It’s the culmination of about 13 years of reverse engineering experience, applying the offensive skills I’ve developed and synthesising/building on the best defensive techniques I encountered on the journey.

# Useful but Little-Known Features of Claude Agent SDK 🌍 Define custom functions as agent tools running in-process using the @tool decorator and create_sdk_mcp_server. Give your agents access to databases, external APIs, and domain-specific logic without managing separate processes. 📌 Title: In-Process Custom Tools (create_sdk_mcp_server / @tool) 🔗 URL: 🧩 Overview Custom tools let you define your own functions that Claude can call during conversations. In Python, use the `@tool` decorator; in TypeScript, use the `tool()` helper. Define a name, description, input schema, and async handler, then wrap tools in `create_sdk_mcp_server` and pass them to `query()`. Tools run in-process — no separate process needed. Tool names follow the `mcp__{server_name}__{tool_name}` convention. Use `readOnlyHint` annotations to enable parallel execution, `isError` for recoverable failures, and return images (base64), resources, or structured content. 🛠 Usage Define tools with the `@tool` decorator and bundle them into an in-process MCP server. ```python from typing import Any import httpx from claude_agent_sdk import tool, create_sdk_mcp_server, query, ClaudeAgentOptions, ResultMessage @tool( "get_temperature", "Get the current temperature at a location", {"latitude": float, "longitude": float}, ) async def get_temperature(args: dict[str, Any]) -> dict[str, Any]: async with httpx.AsyncClient() as client: response = await client.get( "", params={ "latitude": args["latitude"], "longitude": args["longitude"], "current": "temperature_2m", }, ) data = response.json() return { "content": [ {"type": "text", "text": f"Temperature: {data['current']['temperature_2m']}"} ] } # Wrap in an in-process MCP server weather_server = create_sdk_mcp_server( name="weather", version="1.0.0", tools=[get_temperature], ) # Pass to query() async for message in query( prompt="What's the temperature in Tokyo?", options=ClaudeAgentOptions( mcp_servers={"weather": weather_server}, allowed_tools=["mcp__weather__get_temperature"], ), ): if isinstance(message, ResultMessage) and message.subtype == "success": print(message.result) ``` 🏗 Integration into Production Systems - Return `{"is_error": True}` instead of throwing exceptions to keep the agent loop alive and let Claude attempt recovery - Set `readOnlyHint=True` on side-effect-free tools to enable parallel execution with other read-only tools - Return images via `{"type": "image", "data": base64_str, "mimeType": "image/png"}` content blocks - Use `structuredContent` to return machine-readable JSON alongside content (note: not supported by Python `@tool` — requires standalone MCP server) 💡 Use Cases 🗄 Database access: let agents execute DB queries directly 🌐 External API integration: expose internal APIs or third-party services as tools 📊 Data visualization: generate charts and return them as base64 images 🔧 Domain logic: encapsulate calculations, conversions, and validations as callable tools ⚠️ Caveats - Python dict schema treats all keys as required; for optional parameters, omit from schema, describe in the description, and read with `args.get()` - `structuredContent` is not forwarded by Python's `@tool` decorator (use a standalone MCP server) - Tool search is on by default and defers SDK MCP tool schemas; with it disabled, every tool in the `tools` array consumes context on every turn - Annotations are metadata, not enforcement — a `readOnlyHint=True` tool can still write if the handler does so ✨ In-process custom tools let you freely extend agent capabilities with your own functions, without the overhead of managing external processes. #ClaudeAgentSDK# #AIAgent#

Copy-pasting API keys into agent tools in 2026 is ridiculous. So we removed that step. AIsa OAuth is live. Add AIsa MCP → sign in → approve → done. API keys still work. You just don’t have to touch one anymore.

Docker is containerizing the AI AGENT itself now. Its new open-source Kits package: - Agent - Tools - Credentials - Network permissions - Environment Then ship the whole thing as an OCI artifact and run it in an isolated microVM. This feels like a VERY important infrastructure layer for agents. 👇

We’re also launching the Agent Tools API. With just a few lines of code, developers can enable Grok to autonomously browse the web, search X posts, execute code, retrieve uploaded documents, and more.

Introducing Grok 4.1 Fast and the xAI Agent Tools API. Grok 4.1 Fast is our best tool-calling model to date. With a 2M context window, it shines in real-world use cases like customer support and deep research.

People are building entire virtual quant hedge funds in just two days using AI Agent tools like OpenClaw. 🤯 The future of trading is autonomous Agent swarms. But for these virtual traders to truly operate, they need a frictionless financial rail to move value. Pan Network provides the gasless, native payment infrastructure so your AI employees can execute trades and settle transactions seamlessly. 🤖💳⚡️ #OpenClaw# #AIAgents# #PanNetwork# #FutureOfFinance#