Skip to main content
subagent CX Codex

result-overrides — Claude Code subagent: setup and install

The result-overrides subagent explains how middleware can intercept and change an agent’s output. Use it when a response needs editing before it reaches the caller.

MIT ★ 521 updated 2026-10-29

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/agents/result-overrides.md
Open on GitHub

What result-overrides does

Middleware lets the original agent run first, then changes the result. The C# example adds a disclaimer to assistant messages. In Python, the weather function’s result is replaced with a custom response; the streaming example transforms response chunks and can append a validation note at the end.

The subagent covers result overrides for Claude Code, Cursor, and Codex, with a separate agent file path for each platform. For Claude Code, use .claude/agents/result-overrides.md. The C# sample uses DefaultAzureCredential; its production guidance recommends choosing a specific credential, since fallback probing can introduce latency and security risks.

What it helps with

  • append a disclaimer to assistant messages
  • replace a function result with a custom response
  • modify agent output before returning it to the caller
  • transform chunks in a streaming response

Example prompts for the agent

  • Show me how to use middleware to add a disclaimer to assistant messages.
  • Explain how to replace the weather function’s result with a custom response.
  • Show how to transform streamed output and append a validation note at the end.

How to install result-overrides

Manually: put the files in place

.claude/agents/result-overrides.md

For all projects use ~/.claude/agents/. Claude delegates by the description field or an @-mention

Step by step, with commands for each platform: Claude Code subagents: how to create one, call it and keep context clean

Questions about result-overrides

How do I install result-overrides in Claude Code?

Add the subagent file at .claude/agents/result-overrides.md.

What does result-overrides do?

It describes how middleware can intercept an agent’s result and change it, such as by adding text or replacing the response.

How does result-overrides handle streaming?

The Python example transforms response chunks and uses a finalizer to append a validation note.

Source text

result-overrides.md · MIT
---
title: "Result Overrides"
description: "Learn how to override agent results using middleware."
zone_pivot_groups: programming-languages
author: eavanvalkenburg
ms.topic: reference
ms.author: edvan
ms.date: 05/27/2026
ms.service: agent-framework
---

# Result Overrides

Result override middleware allows you to intercept and modify the output of an agent before it is returned to the caller. This is useful for content transformation, response enrichment, or replacing agent output entirely.

:::zone pivot="programming-language-csharp"

In C#, you can override results by modifying the `AgentResponse` returned from the agent run:

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

// Middleware that modifies the AgentResponse after the agent completes
async Task<AgentResponse> ResultOverrideMiddleware(
    IEnumerable<ChatMessage> messages,
    AgentSession? session,
    AgentRunOptions? options,
    AIAgent innerAgent,
    CancellationToken cancellationToken)
{
    var response = await innerAgent.RunAsync(messages, session, options, cancellationToken);

    // Post-process: append a disclaimer to every assistant message
    var modifiedMessages = response.Messages.Select(msg =>
    {
        if (msg.Role == ChatRole.Assistant && msg.Text is not null)
        {
            return new ChatMessage(ChatRole.Assistant,
                msg.Text + "\n\n_Disclaimer: This information is AI-generated._");
        }
        return msg;
    }).ToList();

    return new AgentResponse(modifiedMessages);
}

AIAgent agent = new AIProjectClient(
    new Uri("<your-foundry-project-endpoint>"),
    new DefaultAzureCredential())
        .AsAIAgent(
            model: "gpt-4o-mini",
            instructions: "You are a helpful weather assistant.");

var agentWithOverride = agent
    .AsBuilder()
        .Use(runFunc: ResultOverrideMiddleware, runStreamingFunc: null)
    .Build();

Console.WriteLine(await agentWithOverride.RunAsync("What's the weather in Seattle?"));
```

> [!WARNING]
> `DefaultAzureCredential` is convenient for development but requires careful consideration in production. In production, consider using a specific credential (e.g., `ManagedIdentityCredential`) to avoid latency issues, unintended credential probing, and potential security risks from fallback mechanisms.

:::zone-end

:::zone pivot="programming-language-python"

### Weather override middleware

This example overrides agent results for both streaming and non-streaming scenarios:

```python
# Copyright (c) Microsoft. All rights reserved.

import asyncio
import re
from collections.abc import Awaitable, Callable
from random import randint
from typing import Annotated

from agent_framework import (
    AgentContext,
    AgentResponse,
    AgentResponseUpdate,
    ChatContext,
    ChatResponse,
    ChatResponseUpdate,
    Message,
    ResponseStream,
    tool,
)
from agent_framework.openai import OpenAIChatClient
from pydantic import Field

"""
Result Override with MiddlewareTypes (Regular and Streaming)

This sample demonstrates how to use middleware to intercept and modify function results
after execution, supporting both regular and streaming agent responses. The example shows:

- How to execute the original function first and then modify its result
- Replacing function outputs with custom messages or transformed data
- Using middleware for result filtering, formatting, or enhancement
- Detecting streaming vs non-streaming execution using context.stream
- Overriding streaming results with custom async generators

The weather override middleware lets the original weather function execute normally,
then replaces its result with a custom "perfect weather" message. For streaming responses,
it creates a custom async generator that yields the override message in chunks.
"""


# NOTE: approval_mode="never_require" is for sample brevity. Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py and samples/02-agents/tools/function_tool_with_approval_and_sessions.py.
@tool(approval_mode="never_require")
def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."


async def weather_override_middleware(context: ChatContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Chat middleware that overrides weather results for both streaming and non-streaming cases."""

    # Let the original agent execution complete first
    await call_next()

    # Check if there's a result to override (agent called weather function)
    if context.result is not None:
        # Create custom weather message
        chunks = [
            "due to special atmospheric conditions, ",
            "all locations are experiencing perfect weather today! ",
            "Temperature is a comfortable 22°C with gentle breezes. ",
            "Perfect day for outdoor activities!",
        ]

        if context.stream and isinstance(context.result, ResponseStream):
            index = {"value": 0}

            def _update_hook(update: ChatResponseUpdate) -> ChatResponseUpdate:
                for content in update.contents or []:
                    if not content.text:
                        continue
                    content.text = f"Weather Advisory: [{index['value']}] {content.text}"
                    index["value"] += 1
                return update

            context.result.with_transform_hook(_update_hook)
        else:
            # For non-streaming: just replace with a new message
            current_text = context.result.text if isinstance(context.result, ChatResponse) else ""
            custom_message = f"Weather Advisory: [0] {''.join(chunks)} Original message was: {current_text}"
            context.result = ChatResponse(messages=[Message(role="assistant", contents=[custom_message])])


async def validate_weather_middleware(context: ChatContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Chat middleware that simulates result validation for both streaming and non-streaming cases."""
    await call_next()

    validation_note = "Validation: weather data verified."

    if context.result is None:
        return

    if context.stream and isinstance(context.result, ResponseStream):

        def _append_validation_note(response: ChatResponse) -> ChatResponse:
            response.messages.append(Message(role="assistant", contents=[validation_note]))
            return response

        context.result = context.result.with_finalizer(_append_validation_note)
    elif isinstance(context.result, ChatResponse):
        context.result.messages.append(Message(role="assistant", contents=[validation_note]))


async def agent_cleanup_middleware(context: AgentContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Agent middleware that validates chat middleware effects and cleans the result."""
    await call_next()

    if context.result is None:
        return

    validation_note = "Validation: weather data verified."

    state = {"found_prefix": False}

    def _sanitize(response: AgentResponse) -> AgentResponse:
        found_prefix = state["found_prefix"]
        found_validation = False
        cleaned_messages: list[Message] = []

        for message in response.messages:
            text = message.text
            if text is None:
                cleaned_messages.append(message)
                continue

            if validation_note in text:
                found_validation = True
                text = text.replace(validation_note, "").strip()
                if not text:
                    continue

            if "Weather Advisory:" in text:
                found_prefix = True
                text = text.replace("Weather Advisory:", "")

            text = re.sub(r"\[\d+\]\s*", "", text)

            cleaned_messages.append(
                Message(
                    role=message.role,
                    contents=[text.strip()],
                    author_name=message.author_name,
                    message_id=message.message_id,
                    additional_properties=message.additional_properties,
                    raw_representation=message.raw_representation,
                )
            )

        if not found_prefix:
            raise RuntimeError("Expected chat middleware prefix not found in agent response.")
        if not found_validation:
            raise RuntimeError("Expected validation note not found in agent response.")

        cleaned_messages.append(Message(role="assistant", contents=[" Agent: OK"]))
        response.messages = cleaned_messages
        return response

    if context.stream and isinstance(context.result, ResponseStream):

        def _clean_update(update: AgentResponseUpdate) -> AgentResponseUpdate:
            for content in update.contents or []:
                if not content.text:
                    continue
                text = content.text
                if "Weather Advisory:" in text:
                    state["found_prefix"] = True
                    text = text.replace("Weather Advisory:", "")
                text = re.sub(r"\[\d+\]\s*", "", text)
                content.text = text
            return update

        context.result.with_transform_hook(_clean_update)
        context.result = context.result.with_finalizer(_sanitize)
    elif isinstance(context.result, AgentResponse):
        context.result = _sanitize(context.result)


async def main() -> None:
    """Example demonstrating result override with middleware for both streaming and non-streaming."""
    print("=== Result Override MiddlewareTypes Example ===")

    # For authentication, run `az login` command in terminal or replace AzureCliCredential with preferred
    # authentication option.
    agent = OpenAIChatClient(
        middleware=[validate_weather_middleware, weather_override_middleware],
    ).as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather assistant. Use the weather tool to get current conditions.",
        tools=get_weather,
        middleware=[agent_cleanup_middleware],
    )
    # Non-streaming example
    print("\n--- Non-streaming Example ---")
    query = "What's the weather like in Seattle?"
    print(f"User: {query}")
    result = await agent.run(query)
    print(f"Agent: {result}")

    # Streaming example
    print("\n--- Streaming Example ---")
    query = "What's the weather like in Portland?"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)
    response = agent.run(query, stream=True)
    async for chunk in response:
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print("\n")
    print(f"Final Result: {(await response.get_final_response()).text}")


if __name__ == "__main__":
    asyncio.run(main())
```

### Validation middleware

This example validates agent results and modifies them if needed:

```python
# Copyright (c) Microsoft. All rights reserved.

import asyncio
import re
from collections.abc import Awaitable, Callable
from random import randint
from typing import Annotated

from agent_framework import (
    AgentContext,
    AgentResponse,
    AgentResponseUpdate,
    ChatContext,
    ChatResponse,
    ChatResponseUpdate,
    Message,
    ResponseStream,
    tool,
)
from agent_framework.openai import OpenAIChatClient
from pydantic import Field

"""
Result Override with MiddlewareTypes (Regular and Streaming)

This sample demonstrates how to use middleware to intercept and modify function results
after execution, supporting both regular and streaming agent responses. The example shows:

- How to execute the original function first and then modify its result
- Replacing function outputs with custom messages or transformed data
- Using middleware for result filtering, formatting, or enhancement
- Detecting streaming vs non-streaming execution using context.stream
- Overriding streaming results with custom async generators

The weather override middleware lets the original weather function execute normally,
then replaces its result with a custom "perfect weather" message. For streaming responses,
it creates a custom async generator that yields the override message in chunks.
"""


# NOTE: approval_mode="never_require" is for sample brevity. Use "always_require" in production; see samples/02-agents/tools/function_tool_with_approval.py and samples/02-agents/tools/function_tool_with_approval_and_sessions.py.
@tool(approval_mode="never_require")
def get_weather(
    location: Annotated[str, Field(description="The location to get the weather for.")],
) -> str:
    """Get the weather for a given location."""
    conditions = ["sunny", "cloudy", "rainy", "stormy"]
    return f"The weather in {location} is {conditions[randint(0, 3)]} with a high of {randint(10, 30)}°C."


async def weather_override_middleware(context: ChatContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Chat middleware that overrides weather results for both streaming and non-streaming cases."""

    # Let the original agent execution complete first
    await call_next()

    # Check if there's a result to override (agent called weather function)
    if context.result is not None:
        # Create custom weather message
        chunks = [
            "due to special atmospheric conditions, ",
            "all locations are experiencing perfect weather today! ",
            "Temperature is a comfortable 22°C with gentle breezes. ",
            "Perfect day for outdoor activities!",
        ]

        if context.stream and isinstance(context.result, ResponseStream):
            index = {"value": 0}

            def _update_hook(update: ChatResponseUpdate) -> ChatResponseUpdate:
                for content in update.contents or []:
                    if not content.text:
                        continue
                    content.text = f"Weather Advisory: [{index['value']}] {content.text}"
                    index["value"] += 1
                return update

            context.result.with_transform_hook(_update_hook)
        else:
            # For non-streaming: just replace with a new message
            current_text = context.result.text if isinstance(context.result, ChatResponse) else ""
            custom_message = f"Weather Advisory: [0] {''.join(chunks)} Original message was: {current_text}"
            context.result = ChatResponse(messages=[Message(role="assistant", contents=[custom_message])])


async def validate_weather_middleware(context: ChatContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Chat middleware that simulates result validation for both streaming and non-streaming cases."""
    await call_next()

    validation_note = "Validation: weather data verified."

    if context.result is None:
        return

    if context.stream and isinstance(context.result, ResponseStream):

        def _append_validation_note(response: ChatResponse) -> ChatResponse:
            response.messages.append(Message(role="assistant", contents=[validation_note]))
            return response

        context.result = context.result.with_finalizer(_append_validation_note)
    elif isinstance(context.result, ChatResponse):
        context.result.messages.append(Message(role="assistant", contents=[validation_note]))


async def agent_cleanup_middleware(context: AgentContext, call_next: Callable[[], Awaitable[None]]) -> None:
    """Agent middleware that validates chat middleware effects and cleans the result."""
    await call_next()

    if context.result is None:
        return

    validation_note = "Validation: weather data verified."

    state = {"found_prefix": False}

    def _sanitize(response: AgentResponse) -> AgentResponse:
        found_prefix = state["found_prefix"]
        found_validation = False
        cleaned_messages: list[Message] = []

        for message in response.messages:
            text = message.text
            if text is None:
                cleaned_messages.append(message)
                continue

            if validation_note in text:
                found_validation = True
                text = text.replace(validation_note, "").strip()
                if not text:
                    continue

            if "Weather Advisory:" in text:
                found_prefix = True
                text = text.replace("Weather Advisory:", "")

            text = re.sub(r"\[\d+\]\s*", "", text)

            cleaned_messages.append(
                Message(
                    role=message.role,
                    contents=[text.strip()],
                    author_name=message.author_name,
                    message_id=message.message_id,
                    additional_properties=message.additional_properties,
                    raw_representation=message.raw_representation,
                )
            )

        if not found_prefix:
            raise RuntimeError("Expected chat middleware prefix not found in agent response.")
        if not found_validation:
            raise RuntimeError("Expected validation note not found in agent response.")

        cleaned_messages.append(Message(role="assistant", contents=[" Agent: OK"]))
        response.messages = cleaned_messages
        return response

    if context.stream and isinstance(context.result, ResponseStream):

        def _clean_update(update: AgentResponseUpdate) -> AgentResponseUpdate:
            for content in update.contents or []:
                if not content.text:
                    continue
                text = content.text
                if "Weather Advisory:" in text:
                    state["found_prefix"] = True
                    text = text.replace("Weather Advisory:", "")
                text = re.sub(r"\[\d+\]\s*", "", text)
                content.text = text
            return update

        context.result.with_transform_hook(_clean_update)
        context.result = context.result.with_finalizer(_sanitize)
    elif isinstance(context.result, AgentResponse):
        context.result = _sanitize(context.result)


async def main() -> None:
    """Example demonstrating result override with middleware for both streaming and non-streaming."""
    print("=== Result Override MiddlewareTypes Example ===")

    # For authentication, run `az login` command in terminal or replace AzureCliCredential with preferred
    # authentication option.
    agent = OpenAIChatClient(
        middleware=[validate_weather_middleware, weather_override_middleware],
    ).as_agent(
        name="WeatherAgent",
        instructions="You are a helpful weather assistant. Use the weather tool to get current conditions.",
        tools=get_weather,
        middleware=[agent_cleanup_middleware],
    )
    # Non-streaming example
    print("\n--- Non-streaming Example ---")
    query = "What's the weather like in Seattle?"
    print(f"User: {query}")
    result = await agent.run(query)
    print(f"Agent: {result}")

    # Streaming example
    print("\n--- Streaming Example ---")
    query = "What's the weather like in Portland?"
    print(f"User: {query}")
    print("Agent: ", end="", flush=True)
    response = agent.run(query, stream=True)
    async for chunk in response:
        if chunk.text:
            print(chunk.text, end="", flush=True)
    print("\n")
    print(f"Final Result: {(await response.get_final_response()).text}")


if __name__ == "__main__":
    asyncio.run(main())
```

:::zone-end

:::zone pivot="programming-language-go"

Go middleware can replace results by yielding its own `agent.ResponseUpdate` values instead of, or in addition to, updates from `next`.

```go
override := agent.MiddlewareFunc(func(next agent.RunFunc, ctx context.Context, messages []*message.Message, options ...agent.Option) iter.Seq2[*agent.ResponseUpdate, error] {
    return func(yield func(*agent.ResponseUpdate, error) bool) {
        blocked := shouldOverride(messages)
        if blocked {
            yield(&agent.ResponseUpdate{
                Contents: message.Contents{&message.TextContent{Text: "This response was replaced by middleware."}},
            }, nil)
            return
        }

        for update, err := range next(ctx, messages, options...) {
            if !yield(update, err) {
                return
            }
        }
    }
})
```

:::zone-end
## Next steps

> [!div class="nextstepaction"]
> [Exception Handling](./exception-handling.md)

© eavanvalkenburg · MIT · managedcode/dotnet-skills

Similar subagents

All subagents for Agent setup: memory, context, orchestration →
langchain-middleware langchain-ai langchain-middleware adds middleware hooks for LangChain agents: pauses execution before dangerous tool calls, lets a human approve, edit or reject the action, intercepts calls for logging and retry logic. CX Codex +1 17,200installs llm-input-output-guardrail-middleware-development W4L33Dx llm-input-output-guardrail-middleware-development is a Claude Code skill for designing protective middleware around LLM agents. It guides work on untrusted inputs, tool permissions, and outbound data checks. CX Codex +1 ★ 73repo stars result-to-claim wanshuiyin The result-to-claim skill reads your experiment results and decides which claims they back, which they don't, and what evidence is missing. Run it before writing the paper. CX Codex +1 562installs django-expert 0xfurai django-expert — a Claude subagent that writes Django code: ORM models, views, DRF endpoints, middleware and caching. Handy when a task turns on query performance or API shape. CX Codex ★ 1,029repo stars momentic-result-classification momentic-ai momentic-result-classification reads failed Momentic runs through MCP, pinpoints the step where the run first went wrong, explains why, and files the verdict under a category. CX Codex +1 68,500installs pi-result-handling Agents365-ai pi-result-handling — a skill for presenting Pi helper output correctly in Claude Code, Cursor and other IDEs. Preserves review structure, file paths and line numbers as reported. CX Codex +1 2,900installs

From the same set38

The whole set →
structured-outputs structured-outputs guides typed agent output setup in .NET using Azure AI. Helpful when building strict data contracts with C# models or raw JSON Schema definitions. CX Codex ★ 521repo stars termination termination is a Claude Code subagent that uses middleware to stop agents, block disallowed requests, and limit response length. It adds checks before and after an agent run. CX Codex ★ 521repo stars local-mcp-tools local-mcp-tools — a subagent for integrating Model Context Protocol servers into AI agents. Enables agents to access external tools and services through the MCP standard. CX Codex ★ 521repo stars index index is a Claude Code subagent documenting Agent Framework tool types and their support matrix across C#, Python, and Go. CX Codex ★ 521repo stars tool-approval tool-approval — a subagent that walks through the approval pattern: mark a tool as needing a human yes, then send the approve or reject answer back to the agent. CX Codex ★ 521repo stars evaluation Guides agent and workflow evaluation in Agent Framework using local checks, custom functions, and Microsoft Foundry. CX Codex ★ 521repo stars context-providers Guides you through configuring context providers—built-in and custom tools that enrich agent context before execution and process data after. CX Codex ★ 521repo stars chat-middleware chat-middleware — a subagent that intercepts and modifies chat requests before they reach the AI model. Logs prompts, blocks forbidden terms, overrides responses. CX Codex ★ 521repo stars

Project sponsors

Companies that keep this analytics open