LombdaAiAgents 1.0.0

LombdaAgentSDK

⚡ LombdaAgentSDK is a lightweight C# SDK designed to create and run modular "agents" that can execute tasks, manage state, and communicate with your custom infrastructure. Inspired by modern AI/automation agent patterns, it provides a framework for orchestrating workflows and modular logic with minimal overhead.

🚀 Features

• ✅ Simple Agent and State abstractions for building agent workflows.
• ⚙️ Support for state transitions, condition checks, and results.
• 🔍 Plug-and-play: easily inject your own function handlers.
• 📦 .NET Standard compatible – works across .NET Framework and .NET Core.

📂 Installation

You can clone the repo directly:

git clone https://github.com/Johnny2x2/LombdaAgentSDK.git

Or include the library in your solution by adding the project reference.

🔧 Usage

Run an Agent

Agent agent = new Agent(new OpenAIModelClient("gpt-4o-mini"), "Assistant", "Have fun");

RunResult result = await Runner.RunAsync(agent, "Hello World!");

Automatic Structured Output from Type

public struct math_step
{
    public string explanation { get; set; }
    public string output { get; set; }
}

Agent agent = new Agent(
    new OpenAIModelClient("gpt-4o-mini"),
    "Assistant", 
    "Have fun",
    _output_schema: typeof(math_step));

RunResult result = await Runner.RunAsync(agent, "How can I solve 8x + 7 = -23?");

//Helper function to extract json from last message
math_step mathResult = result.ParseJson<math_step>();

Simple Tool Use

void async Task Run()
{
    Agent agent = new Agent(
        new OpenAIModelClient("gpt-4o-mini"), 
        "Assistant", 
        "Have fun",  
        _tools : [GetCurrentWeather]);

    RunResult result = await Runner.RunAsync(agent, "What is the weather in boston?");

    Console.WriteLine(result.Text);
}

[Tool( Description = "Get the current weather in a given location",
       In_parameters_description = [
        "The city and state, e.g. Boston, MA",
        "The temperature unit to use. Infer this from the specified location."
        ])]
public string GetCurrentWeather(string location, Unit unit = Unit.celsius)
{
    // Call the weather API here.
    return $"31 C";
} 

Create Complex Agent Workflows

Create a States

class PlanningState : BaseState<string, WebSearchPlan>
{
    public override async Task<WebSearchPlan> Invoke()
    {
        string instructions = """
            You are a helpful research assistant. 
            Given a query, come up with a set of web searches, to perform to best answer the query. 
            Output between 5 and 20 terms to query for. 
            """;

        Agent agent = new Agent(
            new OpenAIModelClient("gpt-4o-mini"), 
            "Assistant", 
            instructions, 
            _output_schema: typeof(WebSearchPlan));

        return (await Runner.RunAsync(agent, this.Input)).ParseJson<WebSearchPlan>();
    }
}

Connect States Together

PlanningState plannerState = new PlanningState(); 
ResearchState ResearchState = new ResearchState();
ReportingState reportingState = new ReportingState();

//Add input to first branch of state machine with Set Input
plannerState.SetInput("Research for me top 3 best E-bikes under $1500 for mountain trails");

//Setup Transitions between states
plannerState.Transitions.Add(new StateTransition<WebSearchPlan>(IfPlanCreated, ResearchState)); //Check if a plan was generated or Rerun

ResearchState.Transitions.Add(new StateTransition<string>(_ => true, reportingState)); //Use Lambda expression For passthrough to reporting state

reportingState.Transitions.Add(new StateTransition<ReportData>(_ => true, new ExitState())); //Use Lambda expression For passthrough to Exit

Run the StateMachine

//Create State Machine Runner
StateMachine stateMachine = new StateMachine();

//Run the state machine
await stateMachine.Run(plannerState);

//Report on the last state with Results
Console.WriteLine(reportingState.Output.FinalReport);

Creating State Machines

States essentially transforms the Input into the Output

Where FooState : BaseState<InputType, OutputType>

Invoke() Must Return the Output Type (Strongly Typed)

You can only Transition to a state where the Output of the current state is the Input to the next state

class ConvertStringToIntState : BaseState<string, int>
{
    public override async Task<int> Invoke()
    {
        return int.Parse(this.Input)
    }
}

You can build pipelines of states and let the agent transition between them based on the results.

🚦 Roadmap

• Add non async support for agent execution.
• Improve logging and diagnostics.

🤝 Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you’d like to change.

📄 License

MIT

🙌 Acknowledgements

LlmTornado OpenAI-C#