diff --git a/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/OptionSchemaGeneratorTests.cs b/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/OptionSchemaGeneratorTests.cs
index fcad84fdf5..a8cd03fe22 100644
--- a/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/OptionSchemaGeneratorTests.cs
+++ b/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/OptionSchemaGeneratorTests.cs
@@ -3,6 +3,7 @@
 
 using System.CommandLine;
 using System.Text.Json.Nodes;
+using System.Text.Json.Serialization;
 using Microsoft.Mcp.Core.Areas.Server.Commands;
 using Xunit;
 
@@ -183,4 +184,61 @@ public void CreatePropertySchema_WithNullType_Throws()
 
     private static Option<T> CreateOption<T>(string name, string description = "desc", bool required = false) =>
         new(name) { Description = description, Required = required };
+
+    [Fact]
+    public void CreateOutputSchema_ObjectResult_ReturnsObjectRootUnwrapped()
+    {
+        var schema = OptionSchemaGenerator.CreateOutputSchema(OutputSchemaTestJsonContext.Default.OutputSchemaSampleResult);
+
+        // An object-root result already satisfies MCP's "root must be an object" rule, so it is returned
+        // as-is: its own properties are exposed directly rather than nested under a wrapper.
+        Assert.Equal("object", (string?)schema["type"]);
+
+        var properties = Assert.IsType<JsonObject>(schema["properties"]);
+        Assert.True(properties.ContainsKey("name"), "Object-root result should expose its own 'name' property directly.");
+        Assert.False(properties.ContainsKey("value"), "Object-root result must not be wrapped under a 'value' property.");
+    }
+
+    [Fact]
+    public void CreateOutputSchema_ArrayResult_IsWrappedUnderValue()
+    {
+        var schema = OptionSchemaGenerator.CreateOutputSchema(OutputSchemaTestJsonContext.Default.StringArray);
+
+        AssertWrappedValue(schema, expectedInnerType: "array");
+    }
+
+    [Fact]
+    public void CreateOutputSchema_ScalarResult_IsWrappedUnderValue()
+    {
+        var schema = OptionSchemaGenerator.CreateOutputSchema(OutputSchemaTestJsonContext.Default.Int32);
+
+        AssertWrappedValue(schema, expectedInnerType: "integer");
+    }
+
+    // MCP requires the outputSchema root to be an object, so a non-object export (array or scalar) must be
+    // wrapped as { "type": "object", "properties": { "value": <inner> }, "required": ["value"] }.
+    private static void AssertWrappedValue(JsonObject schema, string expectedInnerType)
+    {
+        Assert.Equal("object", (string?)schema["type"]);
+
+        var properties = Assert.IsType<JsonObject>(schema["properties"]);
+        Assert.True(properties.ContainsKey("value"), "Non-object result must be wrapped under a single 'value' property.");
+
+        var inner = Assert.IsType<JsonObject>(properties["value"]);
+        Assert.Equal(expectedInnerType, (string?)inner["type"]);
+
+        var required = Assert.IsType<JsonArray>(schema["required"]);
+        Assert.Contains(required, node => (string?)node == "value");
+    }
 }
+
+// Shared sample result type + source-generated context used by the outputSchema tests. Declaring them in
+// the parent test namespace keeps the schema-shaping contract decoupled from any shipping tool while
+// remaining visible to the nested ToolLoading tests.
+internal sealed record OutputSchemaSampleResult(string Name, int Count);
+
+[JsonSerializable(typeof(OutputSchemaSampleResult))]
+[JsonSerializable(typeof(string[]))]
+[JsonSerializable(typeof(int))]
+[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
+internal sealed partial class OutputSchemaTestJsonContext : JsonSerializerContext;
diff --git a/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoaderTests.cs b/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoaderTests.cs
index 28d6f5d49a..86098735da 100644
--- a/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoaderTests.cs
+++ b/core/Azure.Mcp.Core/tests/Azure.Mcp.Core.Tests/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoaderTests.cs
@@ -9,6 +9,7 @@
 using Microsoft.Mcp.Core.Areas.Server.Commands.ToolLoading;
 using Microsoft.Mcp.Core.Commands;
 using Microsoft.Mcp.Core.Helpers;
+using Microsoft.Mcp.Core.Models;
 using Microsoft.Mcp.Core.Models.Command;
 using Microsoft.Mcp.Core.Options;
 using ModelContextProtocol.Protocol;
@@ -680,6 +681,173 @@ static bool IsNullType(JsonElement type) =>
         }
     }
 
+    [Fact]
+    public async Task ListToolsHandler_CommandWithResultTypeInfo_EmitsObjectOutputSchema()
+    {
+        // Arrange
+        // A fake command that advertises a source-generated result type. GetTool should surface that type as
+        // the tool's outputSchema.
+        var serviceProvider = CommandFactoryHelpers.CreateDefaultServiceProvider();
+        var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
+        var logger = loggerFactory.CreateLogger<CommandFactoryToolLoader>();
+        var toolLoaderOptions = Microsoft.Extensions.Options.Options.Create(new ToolLoaderOptions());
+
+        var fakeCommand = Substitute.For<IBaseCommand>();
+        fakeCommand.GetCommand().Returns(new Command("fake-output-get", "A fake command that advertises a result type."));
+        fakeCommand.Title.Returns("Fake Output Get");
+        fakeCommand.Metadata.Returns(new ToolMetadata());
+        fakeCommand.ResultTypeInfo.Returns(OutputSchemaTestJsonContext.Default.OutputSchemaSampleResult);
+
+        var commandFactory = CommandFactoryHelpers.CreateCommandFactory(serviceProvider);
+        var commandMapField = typeof(CommandFactory).GetField("_commandMap", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        var commandMap = (Dictionary<string, IBaseCommand>)commandMapField!.GetValue(commandFactory)!;
+        commandMap["fake-output-get"] = fakeCommand;
+
+        var toolLoader = new CommandFactoryToolLoader(serviceProvider, commandFactory, toolLoaderOptions, logger);
+        var request = CreateRequest();
+
+        // Act
+        var result = await toolLoader.ListToolsHandler(request, TestContext.Current.CancellationToken);
+
+        // Assert
+        // A migrated command (where ResultTypeInfo != null) must surface an MCP outputSchema whose root is an
+        // object exposing the result record's own properties.
+        var tool = result.Tools.FirstOrDefault(t => t.Name == "fake-output-get");
+        Assert.NotNull(tool);
+        Assert.NotNull(tool.OutputSchema);
+
+        var outputSchema = tool.OutputSchema!.Value;
+        Assert.Equal(JsonValueKind.Object, outputSchema.ValueKind);
+
+        Assert.True(outputSchema.TryGetProperty("type", out var typeProperty), "outputSchema is missing 'type'.");
+        Assert.Equal("object", typeProperty.GetString());
+
+        Assert.True(outputSchema.TryGetProperty("properties", out var properties), "outputSchema is missing 'properties'.");
+        Assert.True(properties.TryGetProperty("name", out _), "outputSchema should expose the result record's 'name' property.");
+    }
+
+    [Fact]
+    public async Task ListToolsHandler_CommandWithoutResultTypeInfo_OmitsOutputSchema()
+    {
+        // Arrange
+        // A fake command that does not advertise a result type (ResultTypeInfo == null, the default value).
+        // GetTool should leave the tool's outputSchema unset so the command gracefully advertises
+        // no structured output.
+        var serviceProvider = CommandFactoryHelpers.CreateDefaultServiceProvider();
+        var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
+        var logger = loggerFactory.CreateLogger<CommandFactoryToolLoader>();
+        var toolLoaderOptions = Microsoft.Extensions.Options.Options.Create(new ToolLoaderOptions());
+
+        var fakeCommand = Substitute.For<IBaseCommand>();
+        fakeCommand.GetCommand().Returns(new Command("fake-noschema-get", "A fake command with no result type."));
+        fakeCommand.Title.Returns("Fake No Schema Get");
+        fakeCommand.Metadata.Returns(new ToolMetadata());
+
+        var commandFactory = CommandFactoryHelpers.CreateCommandFactory(serviceProvider);
+        var commandMapField = typeof(CommandFactory).GetField("_commandMap", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+        var commandMap = (Dictionary<string, IBaseCommand>)commandMapField!.GetValue(commandFactory)!;
+        commandMap["fake-noschema-get"] = fakeCommand;
+
+        var toolLoader = new CommandFactoryToolLoader(serviceProvider, commandFactory, toolLoaderOptions, logger);
+        var request = CreateRequest();
+
+        // Act
+        var result = await toolLoader.ListToolsHandler(request, TestContext.Current.CancellationToken);
+
+        // Assert
+        var tool = result.Tools.FirstOrDefault(t => t.Name == "fake-noschema-get");
+        Assert.NotNull(tool);
+        Assert.Null(tool.OutputSchema);
+    }
+
+    [Fact]
+    public void TryBuildStructuredContent_ObjectResult_IsUnwrapped()
+    {
+        // An object-root command result already satisfies MCP's "structuredContent must be an object" rule,
+        // so it included as-is: its own properties are surfaced directly rather than nested under a
+        // wrapper. This stays aligned with CreateOutputSchema, which leaves object roots unwrapped.
+        var json = SerializeResponse(ResponseResult.Create(
+            new OutputSchemaSampleResult("alpha", 3),
+            OutputSchemaTestJsonContext.Default.OutputSchemaSampleResult));
+
+        var structuredContent = CommandFactoryToolLoader.TryBuildStructuredContent(json);
+
+        Assert.NotNull(structuredContent);
+        var value = structuredContent!.Value;
+        Assert.Equal(JsonValueKind.Object, value.ValueKind);
+        Assert.Equal("alpha", value.GetProperty("name").GetString());
+        Assert.Equal(3, value.GetProperty("count").GetInt32());
+        Assert.False(value.TryGetProperty("value", out _), "Object results must not be wrapped under a 'value' property.");
+    }
+
+    [Fact]
+    public void TryBuildStructuredContent_ArrayResult_IsWrappedUnderValue()
+    {
+        // A non-object payload (array) cannot be the structuredContent root, so it is wrapped under a single
+        // 'value' property - mirroring the wrapping CreateOutputSchema applies to the advertised schema so the
+        // payload validates against it.
+        var json = SerializeResponse(ResponseResult.Create(
+            new[] { "one", "two" },
+            OutputSchemaTestJsonContext.Default.StringArray));
+
+        var structuredContent = CommandFactoryToolLoader.TryBuildStructuredContent(json);
+
+        Assert.NotNull(structuredContent);
+        var value = structuredContent!.Value;
+        Assert.Equal(JsonValueKind.Object, value.ValueKind);
+        Assert.True(value.TryGetProperty("value", out var wrapped), "Array results must be wrapped under a 'value' property.");
+        Assert.Equal(JsonValueKind.Array, wrapped.ValueKind);
+        Assert.Equal(2, wrapped.GetArrayLength());
+    }
+
+    [Fact]
+    public void TryBuildStructuredContent_ScalarResult_IsWrappedUnderValue()
+    {
+        // A scalar payload likewise cannot be the root object, so it is wrapped under 'value' to match the
+        // advertised schema.
+        var json = SerializeResponse(ResponseResult.Create(
+            42,
+            OutputSchemaTestJsonContext.Default.Int32));
+
+        var structuredContent = CommandFactoryToolLoader.TryBuildStructuredContent(json);
+
+        Assert.NotNull(structuredContent);
+        var value = structuredContent!.Value;
+        Assert.Equal(JsonValueKind.Object, value.ValueKind);
+        Assert.True(value.TryGetProperty("value", out var wrapped), "Scalar results must be wrapped under a 'value' property.");
+        Assert.Equal(42, wrapped.GetInt32());
+    }
+
+    [Fact]
+    public void TryBuildStructuredContent_NoResult_ReturnsNull()
+    {
+        // A command that sets no result serializes without a 'results' property (JsonIgnore-when-null), so
+        // there is nothing to mirror and structuredContent is left unset.
+        var json = SerializeResponse(results: null);
+
+        var structuredContent = CommandFactoryToolLoader.TryBuildStructuredContent(json);
+
+        Assert.Null(structuredContent);
+    }
+
+    [Fact]
+    public void TryBuildStructuredContent_NullResultsProperty_ReturnsNull()
+    {
+        // Even if a 'results' property is present but null, there is no payload to mirror.
+        // The realistic serializer path omits null results, so this uses a hand-built response to exercise it.
+        var structuredContent = CommandFactoryToolLoader.TryBuildStructuredContent("{\"results\":null}");
+
+        Assert.Null(structuredContent);
+    }
+
+    // Serializes a CommandResponse exactly as CallToolHandler does, so the structuredContent tests exercise
+    // the real 'results' property name and shape rather than a hand-rolled approximation.
+    private static string SerializeResponse(ResponseResult? results)
+    {
+        var response = new CommandResponse { Status = HttpStatusCode.OK, Results = results };
+        return JsonSerializer.Serialize(response, ModelsJsonContext.Default.CommandResponse);
+    }
+
     // A self-contained enum + options POCO used only by ListToolsHandler_EnumOption_IsExportedAsStringType.
     // Declaring them here keeps the enum-to-schema contract test independent of any shipping tool.
     private enum SchemaSampleLevel
diff --git a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/OptionSchemaGenerator.cs b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/OptionSchemaGenerator.cs
index 76a7e5d075..d06ab63113 100644
--- a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/OptionSchemaGenerator.cs
+++ b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/OptionSchemaGenerator.cs
@@ -112,4 +112,35 @@ public static JsonObject CreateInputSchema(IReadOnlyList<Option> options)
 
         return root;
     }
+
+    /// <summary>
+    /// Builds the <c>outputSchema</c> root <see cref="JsonObject"/> for the supplied result type.
+    /// MCP requires the root schema to be an <c>"object"</c>, so result types that export as a
+    /// non-object root (arrays or scalars) are wrapped under a single <c>value</c> property. Unlike the
+    /// input schema, <c>additionalProperties</c> is intentionally left unset for forward compatibility
+    /// with evolving result shapes.
+    /// </summary>
+    public static JsonObject CreateOutputSchema(JsonTypeInfo resultTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(resultTypeInfo);
+
+        var schema = JsonSchemaExporter.GetJsonSchemaAsNode(resultTypeInfo, ExporterOptions);
+
+        if (schema is JsonObject rootObject && IsObjectRoot(rootObject))
+        {
+            return rootObject;
+        }
+
+        return new JsonObject
+        {
+            ["type"] = "object",
+            ["properties"] = new JsonObject { ["value"] = schema },
+            ["required"] = new JsonArray { (JsonNode)"value" },
+        };
+    }
+
+    private static bool IsObjectRoot(JsonObject schema)
+        => schema["type"] is JsonValue typeValue
+            && typeValue.TryGetValue<string>(out var typeName)
+            && typeName == "object";
 }
diff --git a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoader.cs b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoader.cs
index 0401bd5515..7618695f6a 100644
--- a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoader.cs
+++ b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/CommandFactoryToolLoader.cs
@@ -207,7 +207,7 @@ public override async ValueTask<CallToolResult> CallToolHandler(RequestContext<C
             var jsonResponse = JsonSerializer.Serialize(commandResponse, ModelsJsonContext.Default.CommandResponse);
             var isError = commandResponse.Status < HttpStatusCode.OK || commandResponse.Status >= HttpStatusCode.Ambiguous;
 
-            return McpHelper.InjectToolIdMetadata(new CallToolResult
+            var callToolResult = new CallToolResult
             {
                 Content = [
                     new TextContentBlock {
@@ -215,7 +215,22 @@ public override async ValueTask<CallToolResult> CallToolHandler(RequestContext<C
                     }
                 ],
                 IsError = isError
-            }, command.Id);
+            };
+
+            // When the command advertises an output schema, set its payload as structuredContent so
+            // clients can consume it against the schema. Object payloads are used as-is;
+            // array or scalar payloads are wrapped under a single 'value' property to match the
+            // wrapping applied by OptionSchemaGenerator.CreateOutputSchema
+            if (!isError && command.ResultTypeInfo != null)
+            {
+                var structuredContent = TryBuildStructuredContent(jsonResponse);
+                if (structuredContent != null)
+                {
+                    callToolResult.StructuredContent = structuredContent;
+                }
+            }
+
+            return McpHelper.InjectToolIdMetadata(callToolResult, command.Id);
         }
         catch (Exception ex)
         {
@@ -267,6 +282,13 @@ private static Tool GetTool(string fullName, IBaseCommand command)
         }
         tool.Meta = meta;
 
+        var resultTypeInfo = command.ResultTypeInfo;
+        if (resultTypeInfo != null)
+        {
+            var outputSchema = OptionSchemaGenerator.CreateOutputSchema(resultTypeInfo);
+            tool.OutputSchema = JsonSerializer.SerializeToElement(outputSchema, ServerJsonContext.Default.JsonObject);
+        }
+
         var options = command.GetCommand().Options
             .Where(o => !CommandFactory.IsLearnOption(o))
             .ToList();
@@ -284,6 +306,37 @@ private static Tool GetTool(string fullName, IBaseCommand command)
         return tool;
     }
 
+    /// <summary>
+    /// Extracts the command result payload from a serialized <see cref="CommandResponse"/> and shapes it
+    /// into the <c>structuredContent</c> value. Object payloads are used as-is; array or scalar payloads
+    /// are wrapped under a single <c>value</c> property to match the wrapping applied by
+    /// <see cref="OptionSchemaGenerator.CreateOutputSchema"/>. Returns <see langword="null"/> when there
+    /// is no result payload.
+    /// </summary>
+    /// <remarks><see langword="internal"/> (rather than <see langword="private"/>) so the payload-shaping
+    /// contract can be unit tested directly without exercising the full call-tool pipeline.</remarks>
+    internal static JsonElement? TryBuildStructuredContent(string jsonResponse)
+    {
+        using var document = JsonDocument.Parse(jsonResponse);
+
+        if (!document.RootElement.TryGetProperty("results", out var results))
+        {
+            return null;
+        }
+
+        switch (results.ValueKind)
+        {
+            case JsonValueKind.Object:
+                return results.Clone();
+            case JsonValueKind.Null:
+            case JsonValueKind.Undefined:
+                return null;
+            default:
+                var wrapper = new JsonObject { ["value"] = JsonNode.Parse(results.GetRawText()) };
+                return JsonSerializer.SerializeToElement(wrapper, ServerJsonContext.Default.JsonObject);
+        }
+    }
+
     /// <summary>
     /// Disposes resources owned by this tool loader.
     /// CommandFactoryToolLoader doesn't own external resources that need disposal.
diff --git a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/RegistryToolLoader.cs b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/RegistryToolLoader.cs
index 261b4d9795..047b427018 100644
--- a/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/RegistryToolLoader.cs
+++ b/core/Microsoft.Mcp.Core/src/Areas/Server/Commands/ToolLoading/RegistryToolLoader.cs
@@ -70,7 +70,7 @@ public override async ValueTask<ListToolsResult> ListToolsHandler(RequestContext
             {
                 var exposedTool = string.IsNullOrEmpty(prefix)
                     ? tool
-                    : new Tool { Name = prefix + tool.Name, Description = tool.Description, InputSchema = tool.InputSchema, Annotations = tool.Annotations };
+                    : new Tool { Name = prefix + tool.Name, Description = tool.Description, InputSchema = tool.InputSchema, OutputSchema = tool.OutputSchema, Annotations = tool.Annotations };
                 allToolsResponse.Tools.Add(exposedTool);
             }
         }
diff --git a/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs b/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
index d4fc94b9a2..d56443a6f5 100644
--- a/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
+++ b/core/Microsoft.Mcp.Core/src/Commands/BaseCommand`2.cs
@@ -7,6 +7,7 @@
 using System.Net;
 using System.Reflection;
 using System.Text.Json.Nodes;
+using System.Text.Json.Serialization.Metadata;
 using Azure;
 using Azure.Mcp.Core.Areas.Server;
 using Microsoft.Identity.Client;
@@ -54,6 +55,16 @@ protected BaseCommand()
     public string Title { get; }
     public ToolMetadata Metadata { get; }
 
+    /// <summary>
+    /// Gets the source-generated <see cref="JsonTypeInfo{TResult}"/> for this command's result type.
+    /// Migrated commands override this so the server can advertise an MCP <c>outputSchema</c> and emit
+    /// <c>structuredContent</c>. Commands that have not been migrated return <see langword="null"/> and
+    /// simply advertise no output schema.
+    /// </summary>
+    public virtual JsonTypeInfo<TResult>? ResultTypeInfo => null;
+
+    JsonTypeInfo? IBaseCommand.ResultTypeInfo => ResultTypeInfo;
+
     public Command GetCommand() => _command;
 
     public TOptions BindOptions(ParseResult parseResult)
@@ -109,6 +120,22 @@ async Task<CommandResponse> IBaseCommand.ExecuteAsync(CommandContext context, Pa
         return response;
     }
 
+    /// <summary>
+    /// Stores the command result on the response using <see cref="ResultTypeInfo"/> so it is serialized
+    /// with the same source-generated <see cref="JsonTypeInfo{TResult}"/> used to advertise the
+    /// <c>outputSchema</c>. Only call this from commands that override <see cref="ResultTypeInfo"/>.
+    /// </summary>
+    protected void SetResult(CommandContext context, TResult result)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        var typeInfo = ResultTypeInfo
+            ?? throw new InvalidOperationException(
+                $"Command type '{GetType().FullName}' called {nameof(SetResult)} without overriding {nameof(ResultTypeInfo)}.");
+
+        context.Response.Results = ResponseResult.Create(result, typeInfo);
+    }
+
     protected virtual void HandleException(CommandContext context, Exception ex)
     {
         context.Activity?.SetStatus(ActivityStatusCode.Error)
diff --git a/core/Microsoft.Mcp.Core/src/Commands/IBaseCommand.cs b/core/Microsoft.Mcp.Core/src/Commands/IBaseCommand.cs
index fab14e0413..e2408e517e 100644
--- a/core/Microsoft.Mcp.Core/src/Commands/IBaseCommand.cs
+++ b/core/Microsoft.Mcp.Core/src/Commands/IBaseCommand.cs
@@ -3,6 +3,7 @@
 
 using System.CommandLine.Parsing;
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization.Metadata;
 using Microsoft.Mcp.Core.Models.Command;
 
 namespace Microsoft.Mcp.Core.Commands;
@@ -40,6 +41,13 @@ public interface IBaseCommand
     /// </summary>
     ToolMetadata Metadata { get; }
 
+    /// <summary>
+    /// Gets the JSON type information describing the command's result type, or <see langword="null"/>
+    /// when the command does not advertise a structured result. Used to generate the MCP
+    /// <c>outputSchema</c> and to serialize <c>structuredContent</c>.
+    /// </summary>
+    JsonTypeInfo? ResultTypeInfo => null;
+
     /// <summary>
     /// Gets the command definition
     /// </summary>
diff --git a/docs/output-schema-migration.md b/docs/output-schema-migration.md
new file mode 100644
index 0000000000..b8398b7a6a
--- /dev/null
+++ b/docs/output-schema-migration.md
@@ -0,0 +1,235 @@
+# Migrating Commands to Emit `outputSchema` and `structuredContent`
+
+This guide describes how to opt a toolset's commands into MCP **`outputSchema`** and
+**`structuredContent`**, following the same pattern applied to the App Configuration commands in the
+pilot. It is written so that an AI agent (or a human) can follow it mechanically, one command at a
+time.
+
+> **Cardinal rule: this migration is purely additive. We are describing the result, not changing it.**
+>
+> The existing text `content` block of every tool response stays byte-for-byte identical, and no CLI
+> option, name, or description changes. You are only (a) advertising a schema for the result and
+> (b) echoing the same result payload into `structuredContent`. If a `tools list` diff shows any change
+> to `name`, `description`, `inputSchema`, or annotations — or if the text `content` of a response
+> changes — stop and investigate.
+
+## What this migration does
+
+Two things happen once a command opts in, both driven by the command exposing its result type:
+
+1. **`outputSchema`** — When the server lists tools, it generates a JSON Schema from the command's
+   source-generated `JsonTypeInfo` (via `System.Text.Json.Schema.JsonSchemaExporter`) and attaches it to
+   the tool as `outputSchema`. Result roots that are not JSON objects (arrays or scalars) are wrapped
+   under a single `value` property so the schema is a valid MCP object schema.
+2. **`structuredContent`** — When the tool is invoked, the server takes the command's result payload and
+   also returns it as `structuredContent`, shaped with the **same** wrapping rule so it validates against
+   the advertised `outputSchema`.
+
+The plumbing already exists in `Microsoft.Mcp.Core`. You do **not** touch it when migrating a toolset —
+it activates automatically for any command that exposes a result type:
+
+- ``Commands/BaseCommand`2.cs`` — defines the `ResultTypeInfo` hook and the `SetResult(...)` helper.
+- `Areas/Server/Commands/OptionSchemaGenerator.cs` — `CreateOutputSchema(...)` builds the schema.
+- `Areas/Server/Commands/ToolLoading/CommandFactoryToolLoader.cs` — `GetTool(...)` attaches
+  `outputSchema`; `CallToolHandler(...)` emits `structuredContent` via `TryBuildStructuredContent(...)`.
+
+The only per-command change is: **tell the base command what your result type is, and let the base
+command store the result.**
+
+## Prerequisites
+
+Before migrating a command, verify both of these. If either is false, resolve it first.
+
+1. **The command is on the two-generic pattern** `BaseCommand<TOptions, TResult>` (usually via a
+   subclass such as `SubscriptionCommand<TOptions, TResult>`). The `ResultTypeInfo` hook and the
+   `SetResult` helper only exist on the two-generic base. If the command is still on the legacy
+   one-generic `BaseCommand<TOptions>`, convert it first — see
+   [`option-conversion.md`](./option-conversion.md) — then come back here.
+
+2. **The result type is registered in the toolset's `JsonSerializerContext`.** This is effectively
+   guaranteed: the pre-migration code already passed `XxxJsonContext.Default.<TResult>` to
+   `ResponseResult.Create(...)`, which requires the type to be registered. You will reference that exact
+   same `JsonTypeInfo` from the new `ResultTypeInfo` override, so no new registration is normally needed.
+   (Example: `AppConfigJsonContext` already lists all five result records.)
+
+## Migration steps (per command)
+
+For each command in the toolset, make these three edits.
+
+### Step 1 — Add the `JsonTypeInfo` using directive
+
+```csharp
+using System.Text.Json.Serialization.Metadata;
+```
+
+### Step 2 — Override `ResultTypeInfo`
+
+Add this property to the command class (next to the injected fields is fine). Reference the **same**
+source-generated `JsonTypeInfo` that the command already used when creating its response, and make sure
+its type argument matches the command's declared `TResult`.
+
+```csharp
+public override JsonTypeInfo<KeyValueGetCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.KeyValueGetCommandResult;
+```
+
+> If the `JsonTypeInfo` you previously passed to `ResponseResult.Create` is for a type that is **not**
+> this command's `TResult`, that is a bug in the original command (the advertised schema would not match
+> the serialized result). Fix the mismatch — align `TResult`, the stored result, and `ResultTypeInfo` on
+> one type — rather than papering over it.
+
+### Step 3 — Replace `ResponseResult.Create` with `SetResult`
+
+Anywhere the command sets a **success** result, replace the manual
+`context.Response.Results = ResponseResult.Create(<result>, XxxJsonContext.Default.<TResult>);` with the
+base helper:
+
+```csharp
+SetResult(context, <result>);
+```
+
+`SetResult` serializes with `ResultTypeInfo` — the exact `JsonTypeInfo` you just declared — so the
+`structuredContent` and the `outputSchema` are always generated from the same source of truth.
+
+Leave error handling untouched: `catch` blocks continue to call `HandleException(context, ex)`. Only
+success-path result assignments change.
+
+## Worked example (App Configuration `KeyValueGetCommand`)
+
+**Before:**
+
+```csharp
+using Microsoft.Mcp.Core.Models.Command;
+
+public sealed class KeyValueGetCommand(...)
+    : SubscriptionCommand<KeyValueGetOptions, KeyValueGetCommand.KeyValueGetCommandResult>(subscriptionResolver)
+{
+    // ...
+    public override async Task<CommandResponse> ExecuteAsync(CommandContext context, KeyValueGetOptions options, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var settings = await _appConfigService.GetKeyValues(/* ... */);
+            context.Response.Results = ResponseResult.Create(new(settings ?? []), AppConfigJsonContext.Default.KeyValueGetCommandResult);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError("An exception occurred processing command. Exception: {Exception}", ex);
+            HandleException(context, ex);
+        }
+
+        return context.Response;
+    }
+}
+```
+
+**After:**
+
+```csharp
+using Microsoft.Mcp.Core.Models.Command;
+using System.Text.Json.Serialization.Metadata;              // Step 1
+
+public sealed class KeyValueGetCommand(...)
+    : SubscriptionCommand<KeyValueGetOptions, KeyValueGetCommand.KeyValueGetCommandResult>(subscriptionResolver)
+{
+    // ...
+    public override JsonTypeInfo<KeyValueGetCommandResult>? ResultTypeInfo   // Step 2
+        => AppConfigJsonContext.Default.KeyValueGetCommandResult;
+
+    public override async Task<CommandResponse> ExecuteAsync(CommandContext context, KeyValueGetOptions options, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var settings = await _appConfigService.GetKeyValues(/* ... */);
+            SetResult(context, new(settings ?? []));                          // Step 3
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError("An exception occurred processing command. Exception: {Exception}", ex);
+            HandleException(context, ex);
+        }
+
+        return context.Response;
+    }
+}
+```
+
+That is the entire change. The five App Configuration commands (`AccountListCommand`,
+`KeyValueGetCommand`, `KeyValueSetCommand`, `KeyValueDeleteCommand`, `KeyValueLockSetCommand`) were each
+migrated with exactly these three edits.
+
+## Variations and gotchas
+
+- **Multi-line `ResponseResult.Create` calls.** Some commands wrap the call across several lines (e.g.
+  `KeyValueSetCommand`). Collapse the whole statement into a single `SetResult(context, new(...));`.
+- **Multiple success call sites.** If a command assigns `context.Response.Results` in more than one
+  success branch, replace every one of them with `SetResult`.
+- **Array or scalar result roots need no special handling.** If a command's `TResult` serializes to a
+  JSON array or scalar rather than an object, the infrastructure automatically wraps both the schema and
+  the `structuredContent` under a `value` property. Do not hand-wrap it yourself.
+- **`SetResult` requires the override.** Calling `SetResult` without overriding `ResultTypeInfo` throws
+  `InvalidOperationException` at runtime. Always do Step 2 and Step 3 together.
+- **Do not change `TResult` or its JSON shape.** The result type, the stored value, and `ResultTypeInfo`
+  must all describe the same shape. Changing a record's members changes both the text `content` and the
+  advertised schema — that is out of scope for this migration.
+- **Commands with no result payload.** A command that never sets `context.Response.Results` on success
+  has nothing to describe — leave it alone (do not add an empty `ResultTypeInfo`).
+- **Proxy / namespace mode is already handled.** `RegistryToolLoader` forwards `outputSchema` when it
+  re-exposes prefixed tools, so migrated tools keep their schema in namespace-proxy mode. No action
+  needed.
+
+## Verification
+
+Run these from the repository root, scoped to the toolset you migrated (App Configuration shown):
+
+1. **Build the tool project.**
+   ```powershell
+   dotnet build tools/Azure.Mcp.Tools.AppConfig/src
+   ```
+
+2. **Run the toolset's unit tests.** Existing tests must stay green — the text `content` is unchanged,
+   so no assertions should need updating.
+   ```powershell
+   ./eng/scripts/Test-Code.ps1 -Paths AppConfig
+   ```
+
+3. **Confirm the schema appears (optional but recommended).** Regenerate the tools-list snapshot and
+   confirm each migrated tool now carries an `outputSchema`, while `name`, `description`, and
+   `inputSchema` are unchanged.
+   ```powershell
+   eng/scripts/New-ToolsListFile.ps1 -Suffix after
+   ```
+
+4. **Format.**
+   ```powershell
+   dotnet format --include="tools/Azure.Mcp.Tools.AppConfig/**/*.cs"
+   ```
+
+5. **Changelog.** The core infrastructure ships its own changelog entry. If your namespace opt-in is a
+   user-facing change worth calling out, add a changelog entry per
+   [`changelog-entries.md`](./changelog-entries.md), using the appropriate `-ChangelogPath`.
+
+## Per-command checklist
+
+- [ ] Command is on the two-generic `BaseCommand<TOptions, TResult>` pattern (convert first if not)
+- [ ] Added `using System.Text.Json.Serialization.Metadata;`
+- [ ] Overrode `ResultTypeInfo` with the source-generated `JsonTypeInfo<TResult>` for the command's `TResult`
+- [ ] Replaced every success-path `ResponseResult.Create(...)` with `SetResult(context, ...)`
+- [ ] Left `catch` / `HandleException` paths unchanged
+- [ ] Did **not** change `TResult`, its members, or the text `content`
+- [ ] Built the tool project
+- [ ] Ran the toolset's unit tests (all green)
+- [ ] Confirmed `outputSchema` present and `name`/`description`/`inputSchema` unchanged via `tools list`
+- [ ] Ran `dotnet format`
+
+## Quick reference: old vs new
+
+| Aspect | Before (pre-migration) | After (migrated) |
+|---|---|---|
+| Result type exposed to server | Not exposed | `public override JsonTypeInfo<TResult>? ResultTypeInfo => XxxJsonContext.Default.<TResult>;` |
+| Storing the success result | `context.Response.Results = ResponseResult.Create(<result>, XxxJsonContext.Default.<TResult>);` | `SetResult(context, <result>);` |
+| `using` directives | — | `+ using System.Text.Json.Serialization.Metadata;` |
+| Tool `outputSchema` | Absent | Generated from `ResultTypeInfo` |
+| Response `structuredContent` | Absent | Result payload, same wrapping as the schema |
+| Text `content` block | Unchanged | Unchanged |
+| CLI options / `inputSchema` | Unchanged | Unchanged |
+| Error handling | `HandleException(context, ex)` | `HandleException(context, ex)` (unchanged) |
diff --git a/servers/Azure.Mcp.Server/changelog-entries/vcolin7-add-output-schema.yaml b/servers/Azure.Mcp.Server/changelog-entries/vcolin7-add-output-schema.yaml
new file mode 100644
index 0000000000..fd1f544e0d
--- /dev/null
+++ b/servers/Azure.Mcp.Server/changelog-entries/vcolin7-add-output-schema.yaml
@@ -0,0 +1,3 @@
+changes:
+  - section: "Features Added"
+    description: "MCP tools can now advertise an `outputSchema` and return `structuredContent` describing the shape of their results. Output schemas are generated from each command's source-generated `JsonTypeInfo` via `System.Text.Json.Schema.JsonSchemaExporter`; result roots that are not JSON objects (arrays or scalars) are wrapped under a `value` property so the payload validates against the advertised schema. App Configuration commands are the first to opt in; other namespaces will follow."
diff --git a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/Account/AccountListCommand.cs b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/Account/AccountListCommand.cs
index 4c3659d398..3a87304cd6 100644
--- a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/Account/AccountListCommand.cs
+++ b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/Account/AccountListCommand.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization.Metadata;
 using Azure.Mcp.Core.Commands.Subscription;
 using Azure.Mcp.Core.Services.Azure.Subscription;
 using Azure.Mcp.Tools.AppConfig.Models;
@@ -32,6 +33,8 @@ public sealed class AccountListCommand(ILogger<AccountListCommand> logger, IAppC
     private readonly ILogger<AccountListCommand> _logger = logger;
     private readonly IAppConfigService _appConfigService = appConfigService;
 
+    public override JsonTypeInfo<AccountListCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.AccountListCommandResult;
+
     public override async Task<CommandResponse> ExecuteAsync(CommandContext context, AccountListOptions options, CancellationToken cancellationToken)
     {
         try
@@ -43,7 +46,7 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
                 options.RetryPolicy,
                 cancellationToken);
 
-            context.Response.Results = ResponseResult.Create(new(accounts?.Results ?? [], accounts?.AreResultsTruncated ?? false), AppConfigJsonContext.Default.AccountListCommandResult);
+            SetResult(context, new(accounts?.Results ?? [], accounts?.AreResultsTruncated ?? false));
         }
         catch (Exception ex)
         {
diff --git a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueDeleteCommand.cs b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueDeleteCommand.cs
index fe71e7d506..bc56f20f47 100644
--- a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueDeleteCommand.cs
+++ b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueDeleteCommand.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization.Metadata;
 using Azure.Mcp.Core.Commands.Subscription;
 using Azure.Mcp.Core.Services.Azure.Subscription;
 using Azure.Mcp.Tools.AppConfig.Options.KeyValue;
@@ -32,6 +33,8 @@ public sealed class KeyValueDeleteCommand(ILogger<KeyValueDeleteCommand> logger,
     private readonly ILogger<KeyValueDeleteCommand> _logger = logger;
     private readonly IAppConfigService _appConfigService = appConfigService;
 
+    public override JsonTypeInfo<KeyValueDeleteCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.KeyValueDeleteCommandResult;
+
     public override async Task<CommandResponse> ExecuteAsync(CommandContext context, KeyValueDeleteOptions options, CancellationToken cancellationToken)
     {
         try
@@ -49,7 +52,7 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
             var message = existed
                 ? $"Key '{options.Key}'{labelSuffix} deleted successfully."
                 : $"Key '{options.Key}'{labelSuffix} did not exist in store '{options.Account}'.";
-            context.Response.Results = ResponseResult.Create(new(options.Key, options.Label, existed, message), AppConfigJsonContext.Default.KeyValueDeleteCommandResult);
+            SetResult(context, new(options.Key, options.Label, existed, message));
         }
         catch (Exception ex)
         {
diff --git a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueGetCommand.cs b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueGetCommand.cs
index 92358368fa..2eb6ca6717 100644
--- a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueGetCommand.cs
+++ b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueGetCommand.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization.Metadata;
 using Azure.Mcp.Core.Commands.Subscription;
 using Azure.Mcp.Core.Services.Azure.Subscription;
 using Azure.Mcp.Tools.AppConfig.Models;
@@ -34,6 +35,8 @@ public sealed class KeyValueGetCommand(ILogger<KeyValueGetCommand> logger, IAppC
     private readonly ILogger<KeyValueGetCommand> _logger = logger;
     private readonly IAppConfigService _appConfigService = appConfigService;
 
+    public override JsonTypeInfo<KeyValueGetCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.KeyValueGetCommandResult;
+
     public override void ValidateOptions(KeyValueGetOptions options, ValidationResult validationResult)
     {
         base.ValidateOptions(options, validationResult);
@@ -62,7 +65,7 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
                 options.RetryPolicy,
                 cancellationToken);
 
-            context.Response.Results = ResponseResult.Create(new(settings ?? []), AppConfigJsonContext.Default.KeyValueGetCommandResult);
+            SetResult(context, new(settings ?? []));
         }
         catch (Exception ex)
         {
diff --git a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueSetCommand.cs b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueSetCommand.cs
index 3836d7ce5e..bf1a2fc867 100644
--- a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueSetCommand.cs
+++ b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/KeyValueSetCommand.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization.Metadata;
 using Azure.Mcp.Core.Commands.Subscription;
 using Azure.Mcp.Core.Services.Azure.Subscription;
 using Azure.Mcp.Tools.AppConfig.Options.KeyValue;
@@ -33,6 +34,8 @@ public sealed class KeyValueSetCommand(ILogger<KeyValueSetCommand> logger, IAppC
     private readonly ILogger<KeyValueSetCommand> _logger = logger;
     private readonly IAppConfigService _appConfigService = appConfigService;
 
+    public override JsonTypeInfo<KeyValueSetCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.KeyValueSetCommandResult;
+
     public override async Task<CommandResponse> ExecuteAsync(CommandContext context, KeyValueSetOptions options, CancellationToken cancellationToken)
     {
         try
@@ -48,10 +51,7 @@ await _appConfigService.SetKeyValue(
                 options.ContentType,
                 options.Tags,
                 cancellationToken);
-            context.Response.Results = ResponseResult.Create(
-                new(options.Key, options.Value, options.Label, options.ContentType, options.Tags),
-                AppConfigJsonContext.Default.KeyValueSetCommandResult
-            );
+            SetResult(context, new(options.Key, options.Value, options.Label, options.ContentType, options.Tags));
         }
         catch (Exception ex)
         {
diff --git a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/Lock/KeyValueLockSetCommand.cs b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/Lock/KeyValueLockSetCommand.cs
index a4d8bade3a..d4ef021383 100644
--- a/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/Lock/KeyValueLockSetCommand.cs
+++ b/tools/Azure.Mcp.Tools.AppConfig/src/Commands/KeyValue/Lock/KeyValueLockSetCommand.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.Text.Json.Serialization.Metadata;
 using Azure.Mcp.Core.Commands.Subscription;
 using Azure.Mcp.Core.Services.Azure.Subscription;
 using Azure.Mcp.Tools.AppConfig.Options.KeyValue.Lock;
@@ -34,6 +35,8 @@ public sealed class KeyValueLockSetCommand(ILogger<KeyValueLockSetCommand> logge
     private readonly ILogger<KeyValueLockSetCommand> _logger = logger;
     private readonly IAppConfigService _appConfigService = appConfigService;
 
+    public override JsonTypeInfo<KeyValueLockSetCommandResult>? ResultTypeInfo => AppConfigJsonContext.Default.KeyValueLockSetCommandResult;
+
     public override async Task<CommandResponse> ExecuteAsync(CommandContext context, KeyValueLockSetOptions options, CancellationToken cancellationToken)
     {
         try
@@ -48,7 +51,7 @@ await _appConfigService.SetKeyValueLockState(
                 options.Label,
                 cancellationToken);
 
-            context.Response.Results = ResponseResult.Create(new(options.Key, options.Label, options.Lock ?? false), AppConfigJsonContext.Default.KeyValueLockSetCommandResult);
+            SetResult(context, new(options.Key, options.Label, options.Lock ?? false));
         }
         catch (Exception ex)
         {