diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
index 84174154a2..3572bff826 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentClassSkill.cs
@@ -102,12 +102,18 @@ public abstract class AgentClassSkill<
     private readonly Lazy<IReadOnlyList<AgentSkillResource>?> _resources;
     private readonly Lazy<IReadOnlyList<AgentSkillScript>?> _scripts;
     private readonly Lazy<string> _content;
+    private readonly Func<JsonElement?, AIFunctionArguments>? _argumentMarshaler;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AgentClassSkill{TSelf}"/> class.
     /// </summary>
-    protected AgentClassSkill()
+    /// <param name="argumentMarshaler">
+    /// Optional argument marshaler applied to all scripts in this skill.
+    /// When <see langword="null"/>, the default marshaler is used which expects arguments as a JSON object.
+    /// </param>
+    protected AgentClassSkill(Func<JsonElement?, AIFunctionArguments>? argumentMarshaler = null)
     {
+        this._argumentMarshaler = argumentMarshaler;
         this._resources = new Lazy<IReadOnlyList<AgentSkillResource>?>(this.DiscoverResources);
         this._scripts = new Lazy<IReadOnlyList<AgentSkillScript>?>(this.DiscoverScripts);
         this._content = new Lazy<string>(() => AgentInlineSkillContentBuilder.Build(
@@ -240,7 +246,7 @@ protected AgentSkillResource CreateResource(string name, Delegate method, string
     /// </param>
     /// <returns>A new <see cref="AgentSkillScript"/> instance.</returns>
     protected AgentSkillScript CreateScript(string name, Delegate method, string? description = null, JsonSerializerOptions? serializerOptions = null)
-        => new AgentInlineSkillScript(name, method, description, serializerOptions ?? this.SerializerOptions);
+        => new AgentInlineSkillScript(name, method, description, serializerOptions ?? this.SerializerOptions, this._argumentMarshaler);
 
     private List<AgentSkillResource>? DiscoverResources()
     {
@@ -356,7 +362,8 @@ private static void ValidateResourceMethodParameters(MethodInfo method, Type ski
                 method: method,
                 target: method.IsStatic ? null : this,
                 description: method.GetCustomAttribute<DescriptionAttribute>()?.Description,
-                serializerOptions: this.SerializerOptions));
+                serializerOptions: this.SerializerOptions,
+                argumentMarshaler: this._argumentMarshaler));
         }
 
         return scripts;
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
index 2465431622..ce65777b8e 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkill.cs
@@ -30,6 +30,7 @@ public sealed class AgentInlineSkill : AgentSkill
 {
     private readonly string _instructions;
     private readonly JsonSerializerOptions? _serializerOptions;
+    private readonly Func<JsonElement?, AIFunctionArguments>? _argumentMarshaler;
     private List<AgentInlineSkillResource>? _resources;
     private List<AgentInlineSkillScript>? _scripts;
     private string? _cachedContent;
@@ -45,11 +46,16 @@ public sealed class AgentInlineSkill : AgentSkill
     /// added to this skill. Individual <see cref="AddScript"/> and <see cref="AddResource(string, Delegate, string?, JsonSerializerOptions?)"/>
     /// calls can override this default. When <see langword="null"/>, <see cref="AIJsonUtilities.DefaultOptions"/> is used.
     /// </param>
-    public AgentInlineSkill(AgentSkillFrontmatter frontmatter, string instructions, JsonSerializerOptions? serializerOptions = null)
+    /// <param name="argumentMarshaler">
+    /// Optional argument marshaler applied by default to all scripts added to this skill.
+    /// When <see langword="null"/>, the default marshaler is used which expects arguments as a JSON object.
+    /// </param>
+    public AgentInlineSkill(AgentSkillFrontmatter frontmatter, string instructions, JsonSerializerOptions? serializerOptions = null, Func<JsonElement?, AIFunctionArguments>? argumentMarshaler = null)
     {
         this.Frontmatter = Throw.IfNull(frontmatter);
         this._instructions = Throw.IfNullOrWhitespace(instructions);
         this._serializerOptions = serializerOptions;
+        this._argumentMarshaler = argumentMarshaler;
     }
 
     /// <summary>
@@ -68,6 +74,10 @@ public AgentInlineSkill(AgentSkillFrontmatter frontmatter, string instructions,
     /// added to this skill. Individual <see cref="AddScript"/> and <see cref="AddResource(string, Delegate, string?, JsonSerializerOptions?)"/>
     /// calls can override this default. When <see langword="null"/>, <see cref="AIJsonUtilities.DefaultOptions"/> is used.
     /// </param>
+    /// <param name="argumentMarshaler">
+    /// Optional argument marshaler applied by default to all scripts added to this skill.
+    /// When <see langword="null"/>, the default marshaler is used which expects arguments as a JSON object.
+    /// </param>
     public AgentInlineSkill(
         string name,
         string description,
@@ -76,7 +86,8 @@ public AgentInlineSkill(
         string? compatibility = null,
         string? allowedTools = null,
         AdditionalPropertiesDictionary? metadata = null,
-        JsonSerializerOptions? serializerOptions = null)
+        JsonSerializerOptions? serializerOptions = null,
+        Func<JsonElement?, AIFunctionArguments>? argumentMarshaler = null)
         : this(
             new AgentSkillFrontmatter(name, description, compatibility)
             {
@@ -85,7 +96,8 @@ public AgentInlineSkill(
                 Metadata = metadata,
             },
             instructions,
-            serializerOptions)
+            serializerOptions,
+            argumentMarshaler)
     {
     }
 
@@ -169,7 +181,7 @@ public AgentInlineSkill AddResource(string name, Delegate method, string? descri
     /// <returns>This instance, for chaining.</returns>
     public AgentInlineSkill AddScript(string name, Delegate method, string? description = null, JsonSerializerOptions? serializerOptions = null)
     {
-        (this._scripts ??= []).Add(new AgentInlineSkillScript(name, method, description, serializerOptions ?? this._serializerOptions));
+        (this._scripts ??= []).Add(new AgentInlineSkillScript(name, method, description, serializerOptions ?? this._serializerOptions, this._argumentMarshaler));
         return this;
     }
 }
diff --git a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillScript.cs b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillScript.cs
index c0abc73252..e482cc45ac 100644
--- a/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillScript.cs
+++ b/dotnet/src/Microsoft.Agents.AI/Skills/Programmatic/AgentInlineSkillScript.cs
@@ -20,6 +20,7 @@ namespace Microsoft.Agents.AI;
 internal sealed class AgentInlineSkillScript : AgentSkillScript
 {
     private readonly AIFunction _function;
+    private readonly Func<JsonElement?, AIFunctionArguments> _argumentMarshaler;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AgentInlineSkillScript"/> class from a delegate.
@@ -32,13 +33,18 @@ internal sealed class AgentInlineSkillScript : AgentSkillScript
     /// Optional <see cref="JsonSerializerOptions"/> used to marshal the delegate's parameters and return value.
     /// When <see langword="null"/>, <see cref="AIJsonUtilities.DefaultOptions"/> is used.
     /// </param>
-    public AgentInlineSkillScript(string name, Delegate method, string? description = null, JsonSerializerOptions? serializerOptions = null)
+    /// <param name="argumentMarshaler">
+    /// Optional function for converting raw JSON arguments into <see cref="AIFunctionArguments"/>.
+    /// When <see langword="null"/>, the default marshaler is used which expects arguments as a JSON object.
+    /// </param>
+    public AgentInlineSkillScript(string name, Delegate method, string? description = null, JsonSerializerOptions? serializerOptions = null, Func<JsonElement?, AIFunctionArguments>? argumentMarshaler = null)
         : base(Throw.IfNullOrWhitespace(name), description)
     {
         Throw.IfNull(method);
 
         var options = new AIFunctionFactoryOptions { Name = this.Name, SerializerOptions = serializerOptions };
         this._function = AIFunctionFactory.Create(method, options);
+        this._argumentMarshaler = argumentMarshaler ?? ConvertToFunctionArguments;
     }
 
     /// <summary>
@@ -53,13 +59,18 @@ public AgentInlineSkillScript(string name, Delegate method, string? description
     /// Optional <see cref="JsonSerializerOptions"/> used to marshal the method's parameters and return value.
     /// When <see langword="null"/>, <see cref="AIJsonUtilities.DefaultOptions"/> is used.
     /// </param>
-    public AgentInlineSkillScript(string name, MethodInfo method, object? target, string? description = null, JsonSerializerOptions? serializerOptions = null)
+    /// <param name="argumentMarshaler">
+    /// Optional function for converting raw JSON arguments into <see cref="AIFunctionArguments"/>.
+    /// When <see langword="null"/>, the default marshaler is used which expects arguments as a JSON object.
+    /// </param>
+    public AgentInlineSkillScript(string name, MethodInfo method, object? target, string? description = null, JsonSerializerOptions? serializerOptions = null, Func<JsonElement?, AIFunctionArguments>? argumentMarshaler = null)
         : base(Throw.IfNullOrWhitespace(name), description)
     {
         Throw.IfNull(method);
 
         var options = new AIFunctionFactoryOptions { Name = this.Name, SerializerOptions = serializerOptions };
         this._function = AIFunctionFactory.Create(method, target, options);
+        this._argumentMarshaler = argumentMarshaler ?? ConvertToFunctionArguments;
     }
 
     /// <summary>
@@ -70,19 +81,15 @@ public AgentInlineSkillScript(string name, MethodInfo method, object? target, st
     /// <inheritdoc/>
     public override async Task<object?> RunAsync(AgentSkill skill, JsonElement? arguments, IServiceProvider? serviceProvider, CancellationToken cancellationToken = default)
     {
-        var funcArgs = ConvertToFunctionArguments(arguments);
+        var funcArgs = this._argumentMarshaler(arguments);
         funcArgs.Services = serviceProvider;
 
         return await this._function.InvokeAsync(funcArgs, cancellationToken).ConfigureAwait(false);
     }
 
     /// <summary>
-    /// Converts a raw <see cref="JsonElement"/> to <see cref="AIFunctionArguments"/> for delegate invocation.
+    /// Default argument marshaling: expects arguments as a JSON object whose properties map to the delegate's parameters.
     /// </summary>
-    /// <exception cref="InvalidOperationException">
-    /// Thrown when <paramref name="arguments"/> is provided but is not a JSON object.
-    /// Inline skill scripts expect arguments as a JSON object whose properties map to the delegate's parameters.
-    /// </exception>
     private static AIFunctionArguments ConvertToFunctionArguments(JsonElement? arguments)
     {
         if (arguments is null ||
diff --git a/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/SkillScriptArgumentMarshalerTests.cs b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/SkillScriptArgumentMarshalerTests.cs
new file mode 100644
index 0000000000..325ba3f826
--- /dev/null
+++ b/dotnet/tests/Microsoft.Agents.AI.UnitTests/AgentSkills/SkillScriptArgumentMarshalerTests.cs
@@ -0,0 +1,344 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.UnitTests.AgentSkills;
+
+/// <summary>
+/// Unit tests for argument marshaling integration via <c>Func&lt;JsonElement?, AIFunctionArguments&gt;</c>.
+/// </summary>
+public sealed class SkillScriptArgumentMarshalerTests
+{
+    /// <summary>
+    /// Creates a JsonElement with ValueKind.String containing the given string value.
+    /// This simulates how vLLM backends send arguments as a string-wrapped JSON object.
+    /// </summary>
+    private static JsonElement CreateStringElement(string value)
+    {
+        // JSON encoding of a string value: surround with quotes and escape inner quotes
+        string json = "\"" + value.Replace("\\", "\\\\").Replace("\"", "\\\"") + "\"";
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.Clone();
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_NullArguments_ReturnsEmptyAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", () => "ok");
+        var skill = new AgentInlineSkill("s", "d", "i");
+
+        // Act
+        var result = await script.RunAsync(skill, null, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("ok", result?.ToString());
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_JsonNull_ReturnsEmptyAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", () => "ok");
+        var skill = new AgentInlineSkill("s", "d", "i");
+        using var doc = JsonDocument.Parse("null");
+        var element = doc.RootElement.Clone();
+
+        // Act
+        var result = await script.RunAsync(skill, element, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("ok", result?.ToString());
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_UndefinedArguments_ReturnsEmptyAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", () => "ok");
+        var skill = new AgentInlineSkill("s", "d", "i");
+        JsonElement? element = default(JsonElement); // ValueKind == Undefined
+
+        // Act
+        var result = await script.RunAsync(skill, element, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("ok", result?.ToString());
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_ObjectArguments_PassesPropertiesAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", (string query, int maxResults) => $"{query}:{maxResults}");
+        var skill = new AgentInlineSkill("s", "d", "i");
+        using var doc = JsonDocument.Parse("""{"query":"hello","maxResults":5}""");
+        var element = doc.RootElement.Clone();
+
+        // Act
+        var result = await script.RunAsync(skill, element, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("hello:5", result?.ToString());
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_StringArguments_ThrowsAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", (string query) => query);
+        var skill = new AgentInlineSkill("s", "d", "i");
+        var element = CreateStringElement("{\"query\": \"hello\"}");
+
+        // Act & Assert
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => script.RunAsync(skill, element, null, CancellationToken.None));
+        Assert.Contains("String", ex.Message);
+    }
+
+    [Fact]
+    public async Task DefaultMarshaler_NumberArguments_ThrowsAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript("test", (string query) => query);
+        var skill = new AgentInlineSkill("s", "d", "i");
+        using var doc = JsonDocument.Parse("42");
+        var element = doc.RootElement.Clone();
+
+        // Act & Assert
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => script.RunAsync(skill, element, null, CancellationToken.None));
+        Assert.Contains("Number", ex.Message);
+    }
+
+    [Fact]
+    public async Task InlineSkillScript_UsesCustomMarshaler_WhenProvidedAsync()
+    {
+        // Arrange
+        var script = new AgentInlineSkillScript(
+            "test-script",
+            (string query) => $"result: {query}",
+            argumentMarshaler: StringParsingMarshaler);
+        var skill = new AgentInlineSkill("test-skill", "desc", "instructions");
+
+        // Create string-wrapped JSON arguments (simulating vLLM behavior)
+        var stringArgs = CreateStringElement("{\"query\":\"hello\"}");
+
+        // Act
+        var result = await script.RunAsync(skill, stringArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("result: hello", result?.ToString());
+    }
+
+    [Fact]
+    public async Task InlineSkill_SkillLevelMarshaler_InheritedByScriptsAsync()
+    {
+        // Arrange
+        var skill = new AgentInlineSkill("test-skill", "desc", "instructions", argumentMarshaler: StringParsingMarshaler)
+            .AddScript("search", (string query) => $"found: {query}");
+
+        var script = await skill.GetScriptAsync("search", CancellationToken.None);
+        Assert.NotNull(script);
+
+        // Create string-wrapped JSON arguments
+        var stringArgs = CreateStringElement("{\"query\":\"world\"}");
+
+        // Act
+        var result = await script.RunAsync(skill, stringArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("found: world", result?.ToString());
+    }
+
+    [Fact]
+    public async Task InlineSkillScript_ScriptLevelMarshaler_OverridesSkillLevelAsync()
+    {
+        // Arrange — skill has a throwing marshaler, but script has its own
+        Func<JsonElement?, AIFunctionArguments> throwingMarshaler = ThrowingMarshaler;
+
+        var skill = new AgentInlineSkill("test-skill", "desc", "instructions", argumentMarshaler: throwingMarshaler);
+        // Create a script directly with a per-script marshaler
+        var script = new AgentInlineSkillScript("search", (string query) => $"found: {query}", argumentMarshaler: StringParsingMarshaler);
+
+        // Create string-wrapped JSON arguments
+        var stringArgs = CreateStringElement("{\"query\":\"test\"}");
+
+        // Act — should use scriptMarshaler (not the throwing skill marshaler)
+        var result = await script.RunAsync(skill, stringArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("found: test", result?.ToString());
+    }
+
+    [Fact]
+    public async Task ClassSkill_ArgumentMarshaler_UsedByDiscoveredScriptsAsync()
+    {
+        // Arrange
+        var skill = new TestClassSkillWithMarshaler();
+        var script = await skill.GetScriptAsync("greet", CancellationToken.None);
+        Assert.NotNull(script);
+
+        // Create string-wrapped JSON arguments
+        var stringArgs = CreateStringElement("{\"name\":\"Alice\"}");
+
+        // Act
+        var result = await script.RunAsync(skill, stringArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("Hello, Alice!", result?.ToString());
+    }
+
+    [Fact]
+    public async Task ClassSkill_CreateScript_UsesArgumentMarshalerAsync()
+    {
+        // Arrange — a class skill that defines its scripts programmatically via CreateScript
+        var skill = new TestClassSkillWithCreateScript();
+        var script = await skill.GetScriptAsync("echo", CancellationToken.None);
+        Assert.NotNull(script);
+
+        // Create string-wrapped JSON arguments (simulating vLLM behavior)
+        var stringArgs = CreateStringElement("{\"value\":\"hi\"}");
+
+        // Act
+        var result = await script.RunAsync(skill, stringArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("echo: hi", result?.ToString());
+    }
+
+    [Fact]
+    public async Task ClassSkill_NoMarshaler_UsesDefaultObjectMarshalingAsync()
+    {
+        // Arrange — a class skill without a custom marshaler falls back to default behavior
+        var skill = new TestClassSkillWithoutMarshaler();
+        var script = await skill.GetScriptAsync("greet", CancellationToken.None);
+        Assert.NotNull(script);
+
+        using var doc = JsonDocument.Parse("""{"name":"Bob"}""");
+        var objectArgs = doc.RootElement.Clone();
+
+        // Act — plain JSON object is marshaled by the default marshaler
+        var result = await script.RunAsync(skill, objectArgs, null, CancellationToken.None);
+
+        // Assert
+        Assert.Equal("Hello, Bob!", result?.ToString());
+    }
+
+    [Fact]
+    public async Task ClassSkill_NoMarshaler_StringArguments_ThrowsAsync()
+    {
+        // Arrange — default marshaler rejects string-wrapped arguments
+        var skill = new TestClassSkillWithoutMarshaler();
+        var script = await skill.GetScriptAsync("greet", CancellationToken.None);
+        Assert.NotNull(script);
+
+        var stringArgs = CreateStringElement("{\"name\":\"Bob\"}");
+
+        // Act & Assert
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => script.RunAsync(skill, stringArgs, null, CancellationToken.None));
+        Assert.Contains("String", ex.Message);
+    }
+
+    /// <summary>
+    /// A custom marshaler function that handles string-wrapped JSON (simulating the vLLM fix).
+    /// </summary>
+    private static AIFunctionArguments StringParsingMarshaler(JsonElement? arguments)
+    {
+        if (arguments is null ||
+            arguments.Value.ValueKind == JsonValueKind.Null ||
+            arguments.Value.ValueKind == JsonValueKind.Undefined)
+        {
+            return [];
+        }
+
+        JsonElement element = arguments.Value;
+
+        if (element.ValueKind == JsonValueKind.String)
+        {
+            string? raw = element.GetString();
+            if (raw is not null)
+            {
+                using var innerDoc = JsonDocument.Parse(raw);
+                element = innerDoc.RootElement.Clone();
+            }
+        }
+
+        if (element.ValueKind != JsonValueKind.Object)
+        {
+            throw new InvalidOperationException($"Cannot marshal arguments of kind '{element.ValueKind}'.");
+        }
+
+        var dict = new Dictionary<string, object?>();
+        foreach (var property in element.EnumerateObject())
+        {
+            dict[property.Name] = property.Value;
+        }
+
+        return new AIFunctionArguments(dict);
+    }
+
+    /// <summary>
+    /// A marshaler function that always throws — used to verify override behavior.
+    /// </summary>
+    private static AIFunctionArguments ThrowingMarshaler(JsonElement? arguments)
+    {
+        throw new InvalidOperationException("ThrowingMarshaler should not be called.");
+    }
+
+    /// <summary>
+    /// A class-based skill with a custom argument marshaler.
+    /// </summary>
+    private sealed class TestClassSkillWithMarshaler : AgentClassSkill<TestClassSkillWithMarshaler>
+    {
+        public TestClassSkillWithMarshaler()
+            : base(argumentMarshaler: StringParsingMarshaler)
+        {
+        }
+
+        public override AgentSkillFrontmatter Frontmatter { get; } = new("test-class-skill", "A test class skill.");
+
+        protected override string Instructions => "Test instructions.";
+
+        [AgentSkillScript("greet")]
+        public static string Greet(string name) => $"Hello, {name}!";
+    }
+
+    /// <summary>
+    /// A class-based skill that defines its scripts programmatically via <c>CreateScript</c>,
+    /// passing the constructor-supplied argument marshaler through to each script.
+    /// </summary>
+    private sealed class TestClassSkillWithCreateScript : AgentClassSkill<TestClassSkillWithCreateScript>
+    {
+        public TestClassSkillWithCreateScript()
+            : base(argumentMarshaler: StringParsingMarshaler)
+        {
+        }
+
+        public override AgentSkillFrontmatter Frontmatter { get; } = new("create-script-skill", "A test class skill using CreateScript.");
+
+        protected override string Instructions => "Test instructions.";
+
+        public override IReadOnlyList<AgentSkillScript>? Scripts =>
+            [this.CreateScript("echo", (string value) => $"echo: {value}")];
+    }
+
+    /// <summary>
+    /// A class-based skill without a custom argument marshaler (uses default object marshaling).
+    /// </summary>
+    private sealed class TestClassSkillWithoutMarshaler : AgentClassSkill<TestClassSkillWithoutMarshaler>
+    {
+        public override AgentSkillFrontmatter Frontmatter { get; } = new("default-marshaler-skill", "A test class skill without a marshaler.");
+
+        protected override string Instructions => "Test instructions.";
+
+        [AgentSkillScript("greet")]
+        public static string Greet(string name) => $"Hello, {name}!";
+    }
+}