simpliflow

Simpliflow: The Fastest Way to Build Agentic AI Workflows

If you’ve ever tried to build a multi-step generative AI workflow — chaining LLMs, tools, and APIs — you know the pain: endless glue code, unpredictable outputs, and tangled state management. Simpliflow, an open-source framework introduced in the paper “Simpliflow: An Open Source Modular Framework for Generative AI Agentic Workflow Orchestration” (arXiv:2510.10675), takes a refreshingly minimalistic yet powerful approach to this problem.
Simpliflow’s philosophy is captured in its tagline:
“Start creating and deploying Gen AI (LLM) agents and agentic workflows in seconds — as easy as 1-2-3!”

What Is Simpliflow?
Simpliflow is an open-source Python framework for creating and executing agentic AI workflows — sequences of LLM-powered “agents” that collaborate to achieve complex goals.
Unlike frameworks such as LangChain or AutoGen that emphasize dynamic multi-agent interactions, Simpliflow focuses on clarity and control. Each workflow is modeled as a deterministic linear sequence (think: a finite-state machine) — predictable, reproducible, and easy to debug.
The project is fully open source:
• 📦 PyPI: pypi.org/project/simpliflow
• 💻 Code: github.com/DevenPanchal/simpliflow
• 🧩 Usage Examples: github.com/DevenPanchal/simpliflow-usage
• 📄 Paper: arXiv:2510.10675
Through integration with LiteLLM, Simpliflow supports 100+ LLMs and vendors (OpenAI, Anthropic, Google Gemini, DeepSeek, Hugging Face, and more) out of the box.

Why Simpliflow?
At its core, Simpliflow addresses three persistent pain points in agentic AI development:
1. Complexity and steep learning curves — Most frameworks require learning new abstractions, managing memory, and debugging emergent behavior.
2. Non-determinism — Autonomous agents can behave unpredictably, making reproducibility and debugging difficult.
3. Boilerplate and fragmentation — Integrating LLMs, tools, and human feedback often means wiring together multiple packages.
Simpliflow solves these by providing a declarative, JSON-based approach to defining workflows. Instead of writing long Python scripts, you describe your workflow in a simple configuration file, specifying each agent, its role, task, and any optional human-in-the-loop (HITL) steps or post-processing functions. Then, Simpliflow executes the workflow step by step, logging every action in structured JSON for full transparency.
The result is a framework that lets developers focus on the “what” rather than the “how.” It feels more like configuring a pipeline than building an application from scratch.

Some of simpliflow’s features and capabilities
Simpliflow’s design decisions prioritize usability and transparency:
• Ease of use: Create and run workflows in seconds.
• Extensibility: Plug in any model via LiteLLM; add postprocessor functions for custom actions.
• Human-in-the-loop: Optional checkpoints allow review or correction before proceeding.
• Deterministic execution: Every workflow runs the same way each time, aiding debugging and reproducibility.
• AI-to-Action: Postprocessor functions can actually execute generated code, enabling real-time automation or integration with external systems.
• Visualization and Logging: All agent interactions are stored as JSON and can be visualized using tools like JSON Crack.
These characteristics make Simpliflow particularly well-suited for developers who want rapid prototyping without giving up control.

Core Design and Architecture
At its core, Simpliflow separates workflow definition from workflow execution. This modularity ensures workflows remain transparent, testable, and portable.
Key components include:
• Agent Class (smartagents.py) – defines an individual agent with its role, prompt, and task description. Each agent communicates with any supported LLM via LiteLLM.
• Workflow Engine – orchestrates agent execution in sequence, handles data passing, logging, and Human-in-the-Loop (HITL) approvals. Each run generates a JSON “interaction log” for reproducibility.
• Postprocessor Functions (func.py) – optional user-defined Python functions to validate, transform, or even execute agent outputs (enabling “AI-to-Action” behavior).
• JSON-Based Configuration System – declarative workflow definitions replace boilerplate Python code.

Real-World Use Cases
The simpliflow-usage repository comes with ready-made workflows across diverse domains:
Customer Service: A sentiment analysis workflow that simulates customer care data, cleans it, performs sentiment analysis, and generates visualization—automating what would typically require a full data science team.
Software Development: The foodtruck-website.json workflow mimics an entire development team: a requirements writer creates technical specs, a user story writer translates them, a developer writes Flask/HTML/CSS code, and a unit tester generates test cases—all in one automated sequence.
{
"flow_description": "Design a simple website for a food truck business",
"agents": [
{ "head": "True", "name_of_agent": "RequirementsWriter", "role_of_agent": "Technical Writer", "what_should_agent_do": "Write 3-4 functional requirements for a website selling hotdogs.", "require_human_approval_of_response": "True", "postprocessor_function": "None", "next": "UserStoryWriter" },
{ "head": "False", "name_of_agent": "UserStoryWriter", "role_of_agent": "User Story Writer", "what_should_agent_do": "Create 5 user stories based on the requirements.", "require_human_approval_of_response": "False", "postprocessor_function": "None", "next": "Developer" },
{ "head": "False", "name_of_agent": "Developer", "role_of_agent": "Software Developer", "what_should_agent_do": "Write Python (Flask) and HTML code implementing the user stories.", "require_human_approval_of_response": "False", "postprocessor_function": "None", "next": "Tester" },
{ "head": "False", "name_of_agent": "Tester", "role_of_agent": "Unit Tester", "what_should_agent_do": "Write 5 unit tests for the generated code.", "require_human_approval_of_response": "False", "postprocessor_function": "None", "next": "None" }
]
}

Network Operations: For e.g. to generate and analyze 5G RAN performance data to diagnose issues and optimize resource allocation across network nodes.
Data Analysis: Automated report generation workflows can compile sales and perfor- mance metrics for taking actions. Example included workflow: Ecommerce.json

{
"flow_description": "Simulated raw sales data for an Ecommerce website",
"agents": [
{
"head": "True",
"name_of_agent": "DataSimulator", "role_of_agent": "Data Simulator", "what_should_agent_do": "Write Python
code snippet to generate simulated raw sales for an Ecommerce website. The generated
data should be stored in a Pandas dataframe",
"require_human_approval_of_response": "True",
"postprocessor_function": "None", "next": "DataVisualizer"
},
{
"head": "False",
"name_of_agent": "DataVisualizer", "role_of_agent": "Data Visualizer", "what_should_agent_do": "Write Python
code snippet to visualize this data. Also generate some Donut charts",
"require_human_approval_of_response": "True",
"postprocessor_function": "None", "next": "None"
}
]
}

Content Management: Dynamic input workflows can format brand content, transform data structures, or prepare customer communications at scale.
Scientific Computing: Create, optimize, and execute quantum circuits on real quantum computers through IBM's API—demonstrating simpliflow's ability to interface with specialized external systems.
Actions and External Tool/API use: simpliflow can be interfaced with environments or utilities to actually execute its results.
E.g. PingServer.json can ping a remote server and Realtime-Action-Beeper.json can create and play music from your computer.

{
"flow_description": "Create 2 Beeps from my Windows computer speaker and then play a
long beep from my Windows computer speaker for 10 seconds",
"agents": [
{
"head": "True", "name_of_agent": "BeepCreator",
"role_of_agent": "Beep Creator", "what_should_agent_do": "Write Python
3.11 code snippet to create 2 beeps from my Windows computer speaker. Return only the code snippet. Nothing else. This is important. Do NOT even include backticks ‘‘‘python or ‘‘‘ at the beginning or end of the code
snippet.", "require_human_approval_of_response":
"True", "postprocessor_function": "
execute_python_code", "next": "SineWaveCreator"
},
{
"head": "False",
"name_of_agent": "LongBeepCreator", "role_of_agent": "Long Beep Creator", "what_should_agent_do": "Write Python
3.11 code snippet to play a long beep from my Windows computer speaker for 10 seconds.
Return only the code snippet. Nothing else. This is important.
Do NOT even include ‘‘‘python or ‘‘‘ at the beginning or end of the code snippet.",
"require_human_approval_of_response": "False",
"postprocessor_function": " execute_python_code",
"next": "None"
}
]
}

Developer Experience and Extensibility
Simpliflow embraces modern development workflows. Workflows can be created manually, with assistance from in-IDE AI tools like GitHub Copilot or Cursor, or through the included Interactive Workflow JSON Generator—a web utility that helps you build configuration files visually.

All workflow executions are logged as structured JSON files in an Interactions directory, making debugging straightforward. You can visualize these logs using tools like JSON Crack, providing clear insight into what each agent received and produced.[2]
The framework's modular nature makes integration seamless. Workflows can receive dynamic inputs from databases, APIs, or RAG systems. While simpliflow doesn't include built-in RAG, it works with any vector database you install in your environment—Pinecone, Weaviate, Chroma, you name it.[2]
Multiple workflows can run simultaneously with single lines of code, scheduled triggers support batch processing, and the framework runs anywhere Python does—Windows, Linux, Mac, in any IDE, on local machines or cloud VMs.

Comparison with Other Frameworks
LangChain, AutoGen, and CrewAI are powerful, flexible frameworks that support multi-agent collaboration, memory, and dynamic tool usage. However, their flexibility often introduces complexity. Developers need to manage message passing, tool definitions, and memory systems, which can feel heavy for linear, task-driven workflows.
Simpliflow takes a different stance. It trades autonomy for determinism — making it ideal for structured pipelines where reliability, auditability, and reproducibility matter. Instead of autonomous agents deciding their next moves, Simpliflow executes predefined, linear sequences of steps. This design simplifies debugging, reduces overhead, and eliminates “LLM roulette.”
If your application needs agents to autonomously decide which other agents to invoke, or requires sophisticated inter-agent communication, LangChain or AutoGen will serve you better. Simpliflow excels when you know the process and want to execute it reliably at scale. Simpliflow shines when you need predictable, repeatable workflows that bridge AI reasoning with operational automation.

Business and Research Implications
For businesses and applied researchers, Simpliflow offers a pragmatic way to integrate generative AI into operations. Because workflows are JSON-based and model-agnostic, it’s easy to connect Simpliflow with databases, APIs, or existing enterprise systems. You can define a sequence of intelligent steps that process data, generate code, or even trigger system actions — all within a single Python call.
It’s particularly effective for:
• Automating customer support analytics and reporting.
• Generating and testing software prototypes.
• Processing text, logs, or configuration files at scale.
• Rapidly simulating business or engineering workflows using LLMs.
By offering transparent execution and full logging, Simpliflow also supports compliance and auditability — an increasingly important requirement for enterprise AI systems.

Call-to-Action
Simpliflow represents a refreshing alternative in the agentic AI ecosystem. It strips away the noise, making it possible for any developer or ML engineer to build deterministic AI workflows with ease. Whether you want to automate reporting, prototype AI-driven software, or run experimental multi-step tasks, Simpliflow provides a clear, reproducible foundation.

Getting Started
Ready to try simpliflow? Here's your quickstart:
1. Install the package: pip install simpliflow
2. Clone the usage repository:
git clone https://github.com/DevenPanchal/simpliflow-usage
cd simpliflow-usage/USING-PACKAGE

3. Set up your API keys: Add your LLM provider tokens to a .env file:
OPENAI_API_KEY=your_key_here
ANTHROPIC_API_KEY=your_key_here
# Other keys as required

4. Run an example workflow:
# STEP 1: REQUIRED PARAMETERS (set required parameters like model etc.)
. . . .
# STEP 2: OPTIONAL PARAMETERS
. . . .
# STEP 3: SOME MORE CONFIGURATION (Point to the appropriate workflow/agentsfile and dynamic_input)
. . . .

# STEP 4: RUN THE FLOW!
a, b = sim.call_agents(agentsfile, dynamic_input
, model, creativity, diversity, max_tokens)

5. Create your own workflow: Use the Interactive Workflow JSON Generator or write your JSON configuration manually, defining agents for your specific use case.
The repository (https://github.com/DevenPanchal/simpliflow-usage) includes dozens of example workflows to learn from—customer service, software development, data analysis, network operations, and more.

Also, explore these project repositories and examples:
• Simpliflow GitHub: https://github.com/DevenPanchal/simpliflow
• Simpliflow on PyPI: https://pypi.org/project/simpliflow/
• Project Website: https://devenpanchal.github.io/simpliflow-website/
Agentic AI doesn’t have to be complicated. With Simpliflow, building intelligent workflows in Python can finally be — quite literally — as easy as 1-2-3.