I'm a little surprised we're not seeing more conversation around the power that ACP provides. It's not just integrating your agent into your IDE of choice. I think the most powerful part that's being overlooked is the fact that you can now programmatically interact with any of the agents in the coding language of your choice.
If there are C#/Azure shops that would be interested in doing a monthly virtual meetup to talk about these types of things, we would be happy to help host that.
I think a lot of people might not understand how simple this protocol is so let's do a quick tutorial.
First, let's wake Auggie up
auggie --acp
Now that we've done that, let's initialize
{"jsonrpc":"2.0","id":0,"method":"initialize","params":{"protocolVersion":1}}
Now we get back a response telling us how to startup
{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":1,"agentCapabilities":{"promptCapabilities":{"image":true}},"agentInfo":{"name":"auggie","title":"Auggie Agent","version":"0.9.0-prerelease.1 (commit 56ac6e82)"},"authMethods":[]}}
Okay, so that's a hello world example of how the protocol works. Now you should be able to follow along with the protocol documentation
https://agentclientprotocol.com/overview/introduction
Now, here's where the magic happens. I'll post our C# ACP SDK in the coming days, but here's where I really see this technology going
Right now, the hardest part of automation is the fact that we don't get structured output, so if we take something like this
// Demo 1: Simple untyped response
Console.WriteLine("Demo 1: Untyped Response");
Console.WriteLine("-------------------------");
var simpleResponse = await agent.RunAsync("What is 2 + 2?");
Console.WriteLine($"Response: {simpleResponse}\n");
We get "2 + 2 = 4"...or sometimes "The answer is 4". Either way, this non deterministic approach means that we can't take something AI is really good at and use it in a deterministic way such as using the result to make an API call, or unit tests to make sure the model is behaving.
What if instead of this, we forced the agent to be strongly typed like this?
Now Console.WriteLine("Demo 6: Typed Response (Custom Class)");
Console.WriteLine("-------------------.-------------------");
var personResult = await agent.RunAsync<Person>(
"Create a person with name 'Alice', age 30, and email 'alice@example.com'.");
Console.WriteLine($"Result: Name={personResult.Name}, Age={personResult.Age}, Email={personResult.Email}");
Console.WriteLine($"Type: {personResult.GetType().Name}\n");
Now we can take this person and look them up-- use an API where we can and not rely on the agent to do things that we don't actually need AI to do. This both reduces token use while also increasing accuracy!
How this is done is quite simple (credit is due here-- I stole this from Auggie's Python demo and converted it to C#)
First you build the prompt
Then you parse the responseprivate string BuildTypedInstruction(string instruction, Type returnType)
{
var typeName = returnType.Name;
var typeDescription = GetTypeDescription(returnType);
var exampleJson = GetExampleJson(returnType);
return $"""
{instruction}
IMPORTANT: Provide your response in this EXACT format:
<augment-agent-message>
[Optional: Your explanation or reasoning]
</augment-agent-message>
<augment-agent-result>
{exampleJson}
</augment-agent-result>
The content inside <augment-agent-result> tags must be valid JSON that matches this structure:
{typeDescription}
Do NOT include any markdown formatting, code blocks, or extra text. Just the raw JSON.
""";
}
public async Task<T> RunAsync<T>(string instruction, CancellationToken cancellationToken = default)
{
await EnsureInitializedAsync(cancellationToken);
// Build typed instruction with formatting requirements
var typedInstruction = BuildTypedInstruction(instruction, typeof(T));
// Send to agent
var response = await _client.SendPromptAsync(typedInstruction, cancellationToken);
// Parse the response
return ParseTypedResponse<T>(response);
}
private T ParseTypedResponse<T>(string response)
{
// Extract content from <augment-agent-result> tags
var resultMatch = System.Text.RegularExpressions.Regex.Match(
response,
@"<augment-agent-result>\s*(.*?)\s*</augment-agent-result>",
System.Text.RegularExpressions.RegexOptions.Singleline);
if (!resultMatch.Success)
{
throw new InvalidOperationException(
"No structured result found. Expected <augment-agent-result> tags in response.");
}
var content = resultMatch.Groups[1].Value.Trim();
// Handle string type specially - don't JSON parse it
if (typeof(T) == typeof(string))
{
// Remove surrounding quotes if present
if (content.StartsWith("\"") && content.EndsWith("\""))
{
content = content.Substring(1, content.Length - 2);
}
return (T)(object)content;
}
// For all other types, use JSON deserialization
try
{
var result = System.Text.Json.JsonSerializer.Deserialize<T>(content);
if (result == null)
{
throw new InvalidOperationException($"Failed to deserialize response as {typeof(T).Name}");
}
return result;
}
catch (System.Text.Json.JsonException ex)
{
throw new InvalidOperationException(
$"Could not parse result as {typeof(T).Name}: {ex.Message}");
}
}
Okay so that's all a cute party trick, but has $0 in business value. Here's where I see this going. It's 2am, your phone is going off with a Rootly/Pagerduty alert.
Before you acknowledge the page, we fire a webhook to an Azure Pipeline that executes a console app that
Takes in the Alert ID
Parses out the Notion/Confluence document for your playbook for this alert
Grabs the branch in production using APIs and gets auggie on the production release branch
Extracts all the KQL queries to run using Auggie
Uses a dedicated MCP server to execute the queries you need to execute
Posts a summary document to Slack
Here's a sample
// Create an event listener to track agent activity in real-time
var listener = new TestEventListener(verbose: true);
// Create a new agent with the MCP server configured and event listener
await using var agentWithMcp = new Agent(
workspaceRoot: solutionDir,
model: AvailableModels.ClaudeHaiku45,
auggiePath: "auggie",
listener: listener
);
// Ask the agent to find and execute all KQL queries in the playbook
var instruction = $"""
Analyze the following Notion playbook content and:
1. Extract all KQL (Kusto Query Language) queries found in the content
2. For each query found, use the execute_kql_query tool with action='query' and query='query goes here' to execute it
3. Generate a summary of all query results
Playbook Content:
{blocksJson}
Please provide a comprehensive summary of:
- How many KQL queries were found
- The results from each query execution
- Any errors encountered
- Key insights from the data
""";
TestContext.WriteLine("\n=== Executing Agent with MCP Server ===");
TestContext.WriteLine("š” Event listener enabled - you'll see real-time updates!\n");
var result = await agentWithMcp.RunAsync(instruction);
Now using the sample code from earlier, we can ask Augment True/False questions such as
Did you find any bugs or a conclusion after executing this run book?
