v1.0.0-alpha.3

1.0.0‑alpha.3

This release introduces tryStep, a first‑class way to express typed early‑exit behavior directly inside the main workflow DSL. It replaces the old ResultWorkflow computation expression, offering a simpler, more expressive, and more ergonomic approach to Railway‑Oriented Programming.

✨ Added

• tryStep — a workflow step that returns a Result and short‑circuits the workflow on Error.
  This brings Railway‑Oriented Programming into the core DSL without requiring a separate computation expression.

🛠️ Changed

• Removed ResultWorkflow in favor of tryStep.
  The new design is clearer, avoids monadic contagion, and integrates naturally with both in‑process and Durable workflows.

🔧 Improved

• Refined README structure:
  • Added a concise introduction to tryStep under Features.
  • Replaced redundant sections and improved overall clarity.
  • Added tables for Workflow, Tool, and Agent functions for easier scanning.

1.0.0-alpha.2

v1.0.0-alpha.2

Durable Workflows & Major Refinements

New: AgentNet.Durable Package

Host Agent.NET long-running, enterprise workflows reliably on Azure Durable Functions.
This is the final form of workflow execution in Agent.NET — declarative, typed, and minimal.

let tradeApprovalWorkflow = workflow {
    name "TradeApprovalWorkflow"
    step analyzeStock
    step sendForApproval
    awaitEvent "TradeApproval" eventOf<ApprovalDecision>
    step executeTrade
}

[<Function("TradeApprovalOrchestrator")>]
let orchestrator ([<OrchestrationTrigger>] ctx) =
    let request = ctx.GetInput<TradeRequest>()
    Workflow.Durable.run ctx request tradeApprovalWorkflow

• awaitEvent — suspend workflows waiting for external events (human-in-the-loop patterns)
• Durable execution powered by Microsoft Agent Framework and Azure Durable Functions with automatic checkpointing
• Minimal hosting surface — the orchestrator simply runs the workflow

Workflow CE: Stronger Typing, Cleaner Syntax

The Workflow computation expression has matured into a more predictable, more expressive DSL for defining long‑running workflows.

• SRTP type inference
  Steps now infer input/output types more reliably, reducing annotation noise and making workflows feel more “F#‑native.”
• Plug‑and‑play step composition
  Each step can now be a plain function, Task, Async, TypedAgent, or even a nested workflow — all with consistent typing and execution semantics.
• Compiler‑enforced I/O correctness
  The CE now enforces that each step’s output matches the next step’s input, eliminating entire classes of runtime errors.
• Simplified API surface
  Redundant helpers and experimental constructs have been removed or unified, leaving a smaller, more intentional API.
• Fan‑out ergonomics
  Parallel branches are easier to express and reason about, with clearer type signatures and more predictable behavior.

Why this matters:
Workflows now read like clean, declarative pipelines — and the compiler guarantees correctness.

TypedAgent: Structured, Typed Agent Execution

A new agent type that brings structure and safety to LLM‑powered steps.

• Typed input/output
  Define agents with explicit request and response types for predictable, validated boundaries.
• Prompt + parse model
  Each agent combines a prompt generator with a typed parser, giving you full control over structure and error handling.
• Upgrade path from ChatAgent
  ChatAgent remains supported, but TypedAgent is now the recommended way to build reliable agent steps.

Why this matters:
You get the flexibility of LLM agents with the safety of typed contracts — ideal for workflows that must be correct, resumable, and durable.

Architecture: Cleaner, Safer, More Predictable

This release includes major internal refinements that make Agent.NET more robust and easier to reason about.

• MAF InProcessExecution replaces the prototype runner
  Local execution now mirrors durable execution semantics, reducing conceptual drift between hosts.

• Removal of reflection and obj
  Internal step representation is now fully typed, eliminating reflection‑based dispatch and improving safety.

• C# executors for serialization boundaries
  Durable Functions serialization is now handled internally by explicit C# executors, ensuring compatibility and clarity.

• Stronger internal step model
  Steps are now represented in a more explicit, typed form, improving debuggability and reducing edge cases.

Why this matters:
The engine is now more predictable, more maintainable, and better aligned with the durable execution model.

Cleanup & Polish

• Multi‑targeting for broader compatibility: net8.0, net9.0, net10.0
• Numerous bug fixes and stability improvements
• Durable hosting hardened for real‑world workloads

v1.0.0-alpha.1

v1.0.0-alpha.1

Agent.NET - First Alpha Release 🎉

Elegant agent workflows for .NET, designed in F#.

Highlights

• Quotation-based Tool creation - Use Tool.create <@ myFunction @> to automatically extract function name, parameter names, and types. Use Tool.createWithDocs to also pull XML documentation as descriptions.
• Pipeline-style ChatAgent API - Build agents with a clean, composable pipeline:

ChatAgent.create "You are a helpful assistant."
|> ChatAgent.withTools [tool1; tool2]
|> ChatAgent.build chatClient

• Workflow computation expression - Orchestrate multi-step agent workflows with:
  • Sequential pipelines (step)
  • Parallel execution (fanOut / fanIn)
  • Conditional routing (route)
  • Resilience patterns (retry, timeout, fallback, backoff)
• ResultWorkflow - Railway-oriented programming with automatic error short-circuiting
• In-memory execution via Workflow.runInProcess

This alpha wraps https://github.com/microsoft/agent-framework with idiomatic F# APIs. Feedback welcome!