Project: Reasoning Agents - Gantri Extensible Agent Framework

Track

Reasoning Agents (Azure AI Foundry)

Project Name

Gantri

GitHub Username

JoshuaVarley

Repository URL

https://github.com/JoshuaVarley/Gantri

Project Description

Gantri is a modular, extensible agent framework built on .NET 10 and the Microsoft Agent Framework (AF) that enables developers to build, orchestrate, and schedule AI-powered agents through declarative YAML configuration.

Gantri provides a complete platform for creating autonomous AI agents that can execute tools, collaborate in multi-agent pipelines, run scheduled workflows, and integrate with external services via the Model Context Protocol (MCP) — all without writing boilerplate orchestration code.

Building production-grade AI agents requires solving many cross-cutting concerns simultaneously: plugin isolation, tool access control, human-in-the-loop approval, observability, scheduling, and multi-agent coordination. Gantri unifies these into a single framework with a clean layered architecture, so developers focus on agent behavior rather than infrastructure. Pro developers can also easily develop plugins that can be applied to all agents for complex system or business logic.

Demo Video or Screenshots

screenshots
https://github.com/JoshuaVarley/Gantri/tree/main/resources/screenshots

Examples in Readme.md

Primary Programming Language

C#/.NET

Key Technologies Used

.NET 10 / C# 13 — Runtime and primary language
Microsoft Agent Framework (AF) — Agent execution and function calling
Microsoft.Extensions.AI — LLM provider abstraction layer
Azure OpenAI / Azure AI Foundry — LLM providers (GPT-5-mini, GPT-5.1-codex-mini)
Model Context Protocol (MCP) — External tool discovery and invocation (e.g., Brave Search)
Wasmtime — WASM runtime for sandboxed cross-language plugin execution
TickerQ — Distributed cron/time-based job scheduling with SQLite persistence
OpenTelemetry — Distributed tracing, metrics, and structured logging
Polly — Resilience patterns (retry with exponential backoff)
YamlDotNet — YAML configuration parsing with environment variable substitution
Spectre.Console — Rich interactive REPL and CLI rendering
xUnit — Testing framework (173+ tests across 12 test projects)

Submission Type

Individual

Team Members

No response

Submission Requirements

• My project meets the track-specific challenge requirements
• My repository includes a comprehensive README.md with setup instructions
• My code does not contain hardcoded API keys or secrets
• I have included demo materials (video or screenshots)
• My project is my own work with proper attribution for any third-party code
• I agree to the Code of Conduct
• I have read and agree to the Disclaimer
• My submission does NOT contain any confidential, proprietary, or sensitive information
• I confirm I have the rights to submit this content and grant the necessary licenses

Quick Setup Summary

• Set up and configure Azure OpenAI or Foundry resource
• Deploy models - gpt-5-mini or gpt-5.1-codex recommended.
• Clone the repo and run dotnet build Gantri.slnx
• Copy .env.example to .env and set your AZURE_OPENAI_API_KEY and BRAVE_API_KEY if using Brave MCP example
• Update config/ai.yaml with your Azure OpenAI or Foundry endpoint and model deployment names
• Node.js 18+ required if using MCP servers (a Brave Search example is included)
• Run tests: dotnet test Gantri.slnx
• Launch interactive REPL: dotnet run --project src/Hosts/Gantri.Cli

-Example workflow refer to test-guide.md

Technical Highlights

I'm most proud of the integration architecture. Rather than scattering Microsoft Agent Framework dependencies across the codebase, a dedicated Bridge layer (Layer 2) cleanly adapts Gantri's plugin system, hook pipeline, and MCP integration to AF's APIs. GantriAgentFactory builds AF AIAgent instances from YAML definitions, while PluginActionFunction and McpToolFunction are real AIFunction subclasses that route tool calls through Gantri's unified infrastructure. This means Gantri's unique features (hooks, approval, security) wrap AF transparently without coupling.

Each native plugin loads into its own isolated AssemblyLoadContext, preventing dependency conflicts. Since types lose identity across context boundaries, the loader uses name-based interface matching (i.FullName == "Gantri.Plugins.Sdk.ISdkPluginAction") with reflection bridging — an unconventional but effective solution. WASM plugins extend this further with true sandboxed execution via Wasmtime.

The four-layer design (Contracts → Core → Bridge → Hosts) enforces top-down-only dependencies, making each subsystem independently testable and replaceable.

Challenges & Learnings

Gantri's hook/plugin/MCP systems and Microsoft Agent Framework have fundamentally different extension models. Making them compose cleanly required the Bridge layer abstraction, which took several iterations to get right. The learning: integration layers should be explicit and isolated, not implicit and scattered.

Simple agent workflows should leverage AF directly for efficiency, but complex workflows (parallel steps, approval gates, conditions) need a full engine. Deciding where to draw that line and implementing clean routing between the two paths was a design challenge that reinforced the value of keeping simple things simple.

Contact Information

jvarley@novabyte.net

Country/Region

Australia

Review the linked Gantri repository, README.md, config/ai.yaml, test-guide.md, and the setup commands in this submission. The issue describes a project entry rather than a specific change, so no implementation target or completion criteria are provided; clarify the desired contribution before starting.