Semantic Kernel: Contributing to a Simpler, More Fluent Process Framework ??

The Story: How It Started

Back in mid-September, I had the privilege of being introduced to the Process Framework in Semantic Kernel during a private preview. Evan Chaki invited me, along with Ben Thomas , the lead architect of the Process Framework, just a week before its official release.

From the very first conversation, I could feel the potential of what the Process Framework could become—a flexible, powerful tool for orchestrating workflows in Semantic Kernel. But what really struck me was the openness and collaboration of the team.

I shared feedback, small ideas at first, but something magical happened: I felt heard. Ideas resonated, and a truly motivating process began where conversations flowed freely between Evan, Ben, and other team members like Estefanía T. and also, of course, Chris Rickman .

It’s rare to experience such an energizing environment where your contributions not only matter but spark further innovation. Long story short, I haven’t been this motivated in a while, and from that moment, I knew I wanted to contribute to making the Process Framework even better.

The Vision: Small Steps, Big Impact

Over the past few months, I’ve focused on incremental improvements to the Process Framework. Each contribution aimed to simplify, optimize, and enhance the developer experience, starting with small pain points that could make a big difference.

This is also thanks to the feedback of Chris Rickman who told recommended me not to make big changes or proposals but small, achievable, and easier to review, ones ;) - FYI I did a fully fledged repo with a lot of ideas materialized (and working) - you can peek it if curious, see here: https://github.com/joslat/semantic-kernel/tree/joslat-process-framework-graph-edges.

So, shorter, smaller steps then..

Key Contributions So Far

Here’s how the Process Framework has evolved with these contributions:

• Simplified Fluent Syntax (pending) - https://github.com/microsoft/semantic-kernel/issues/10001
• Rendering Process as a Graph (pending) - https://github.com/microsoft/semantic-kernel/issues/9514
• Simplest Example for Process Framework - https://github.com/microsoft/semantic-kernel/issues/9648
• Automatic Function Event Resolution - https://github.com/microsoft/semantic-kernel/issues/9647
• Simplified Event Emission - https://github.com/microsoft/semantic-kernel/issues/9510

Rendering Workflows with Nested Steps: Bringing It All Together

One of the most exciting improvements to the Process Framework has been the ability to render workflows visually, including processes with nested steps—steps that themselves are processes. This idea was spiced up with the suggestion of nesting steps which are composed of a process, suggested by Ben Thomas , has been a game-changer for understanding complex workflows and debugging them effectively.

For example this is a rendered example with a nesting of 1 and of 2:

Nesting of 2 levels:

Nesting of 1 level:

Nested steps provide the flexibility to modularize processes, breaking them into smaller, reusable components. Visualizing these workflows—especially when they contain nested processes—has uncovered both the power of the framework and some interesting challenges:

1. Clarity in Representation: Representing nested processes as subgraphs in a way that remains clean and easy to follow.
2. Edge Management: Ensuring that transitions between steps, even when deeply nested, are rendered accurately without ambiguity.
3. Complexity in Debugging: The visualization exposed areas where transitions or event handling needed simplification or better error handling.

Thanks to Ben’s suggestion, this feature was improved greatly and will bring the Process Framework to life, visually speaking. Seeing workflows rendered as graphs—complete with steps, edges, and nested components—has been incredibly rewarding. It ties together the improvements we’ve made so far: from simplifying transitions to automating function resolution, all while keeping the developer experience clean and intuitive.

This also made visible some nits and bits (if you are curious, the PR for the graph rendering is linked to an issue discovered during this "Process Framework exploration in depth" that we discussed along Ben & Stefania - but we will probably discuss next year ;).

This journey of visualizing workflows not only makes processes easier to understand but also highlights opportunities for future enhancements, like conditional edges and dynamic entry points.

The Latest: Simplified Fluent Syntax

The most recent contribution tackles one of the biggest friction points: step transitions. The current syntax is functional but verbose, requiring manual step creation and edge management.

With this, we have a more fluent API that simplifies process definitions while retaining all the flexibility.

Before vs After: A Cleaner Process Flow

Current syntax (More verbose):

New Syntax (Simplified and Fluent):

Why It Matters

This improved fluent API:

• Reduces Boilerplate: No more manual edge linking or repetitive code.
• Improves Readability: The process flow reads like a story—easy to follow and maintain.
• Lowers Cognitive Overhead: Developers can focus on the workflow logic instead of managing transitions.

It’s a small but meaningful step towards making the Process Framework as elegant as it is powerful.

You can track the current syntax improvement here on the issue and also, the fully functional PR:

• Issue: https://github.com/microsoft/semantic-kernel/issues/10001
• PR: https://github.com/microsoft/semantic-kernel/pull/10002

Also if you like what you see feel free to state your opinion on the issue :) - or any change or adjustment you would like to see.

Looking Ahead: The Future of the Process Framework

This is just the beginning. The contributions so far have laid a strong foundation, but there’s more to come:

• Conditional Edges: Allowing transitions based on conditions.
• Conditional Entry Edges: Enabling steps to start dynamically based on state or input.
• Descriptions for Process, Steps and Edges
• Improvements on composability (i.e., a process which is a Step)
• Workflow Process visual Designer (I'd like to explore this once all the pending issues are gone so it can be done for good - What would you use for this? ;) Jamie Maguire any suggestion? - I know you would love this to happen :)

You can track ongoing discussions and improvements here on the processes backlog

Conclusion: The Power of Collaboration

What started with a private preview in September has turned into a rewarding journey of small but impactful contributions. None of this would have been possible without the collaborative spirit of the team—Evan, Ben, Chris and Estefania — who created a space where ideas could flow, resonate, and evolve.

This process has reminded me of something important: great frameworks are built one step at a time, through listening, learning, and continuous refinement. (note here the pun of "one step at a time" was unintended, but I love it)

I’m excited to see where the Process Framework goes next, and I’ll continue contributing to make it simpler, cleaner, and even more powerful for everyone. ??

If you’re working with the Process Framework, I’d love to hear your thoughts, ideas, and feedback. Let’s make this journey together! (also, leave a comment so we can connect)

Call to Action

• Try out the new fluent syntax (once the PR is approved - it may not).
• Share your feedback on the open issues.
• Let’s simplify workflows, one step at a time.

Curious about how Generative and Agentic AI are shaping the future? maybe along Semantic Kernel and AutoGen?

Follow José Luis Latorre for real insights and practical examples of these technologies in action.