Stellar Frameworks: An Adaptive Complexity Task Workflow Framework for LLM Agents

This article introduces Stellar Frameworks—a universal task workflow framework for LLM agents, using a phase state machine design and supporting four levels of adaptive complexity (Minimal/Simple/Standard/Complex). It aims to solve the fragmentation problem of LLM agent workflows and provide a unified and flexible processing paradigm for various tasks.

Original Author/Maintainer: hoshiyomiX Source Platform: GitHub Original Title: stellar-frameworks Original Link: https://github.com/hoshiyomiX/stellar-frameworks Publication Date: May 25, 2026

With the evolution of LLM capabilities, agent systems are moving toward practical applications, but developers face the problem of task complexity diversity: the same task has different complexities in different scenarios. Existing frameworks have two extremes: over-simplified (unable to handle complex tasks) or over-complex (code redundancy, difficult maintenance). Stellar Frameworks proposes the concept of "one framework, adaptive complexity" to address this pain point.

Phase State Machine

Modeling task execution as a state machine, where each state represents a task phase. Advantages include clear phase division, traceable states, flexible transitions, and fault tolerance recovery.

Four Levels of Adaptive Complexity

Level	Name	Applicable Scenarios	Resource Consumption
1	Minimal	Simple and direct tasks (clear answers)	Lowest
2	Simple	Tasks requiring a small amount of reasoning/search	Low
3	Standard	Multi-step reasoning/tool calling tasks	Medium
4	Complex	Open-ended problems (in-depth analysis/iterative optimization)	High

Tasks can be dynamically upgraded/downgraded, not statically assigned.

Complexity Evaluator

Evaluate task complexity based on input features, historical patterns, resource constraints, and user preferences.

Dynamic Path Selection

• Minimal: Direct single LLM call (factual Q&A, simple conversion)
• Simple: Single call + lightweight retrieval/tools (requires a small amount of background knowledge)
• Standard: Multi-phase processing (reasoning chain, tool sequence, verification)
• Complex: Iterative optimization, multi-round dialogue, advanced retrieval (research questions)

Downgrade and Upgrade Strategies

• Upgrade triggers: Substandard output quality, user requests for details, need for additional steps
• Downgrade triggers: Resource limitations, timeout, user requests for conciseness, simpler task

Bidirectional adaptation ensures optimal resource utilization.

Customer Service Agent

• Minimal: Business hours inquiry → directly return from knowledge base
• Simple: Password reset → retrieve help document and summarize
• Standard: Order not received → query status + logistics + analyze delay
• Complex: Custom solution → multi-round requirement collection + recommendation + quotation

Code Assistant

• Minimal: Syntax check, simple refactoring
• Simple: Generate common functions, explain code
• Standard: Debug errors, optimize performance, generate unit tests
• Complex: Architecture design, cross-file refactoring, technology selection

Research Assistant

• Minimal: Definition explanation, concept clarification
• Simple: Literature search, summary generation
• Standard: Literature review, comparative analysis, hypothesis generation
• Complex: Experiment design, data analysis, paper assistance

State Machine Engine

May use existing libraries (Python transitions, TypeScript xstate) or custom implementations. The key points are configurable transitions and observability.

Prompt Engineering Templates

Each level has supporting prompt templates, which need to be optimized for different LLMs.

Evaluation and Feedback Mechanism

• Self-evaluation: LLM's confidence in output
• Rule-based evaluation: Heuristic quality checks
• External feedback: User feedback, tool results, downstream success rate

Tool Integration Layer

Standard/Complex levels need to integrate external tools (search, database, API, etc.), providing unified registration, calling, and error handling.

Feature	Stellar Frameworks	LangChain	AutoGPT	BabyAGI
Complexity Hierarchy	✅ Four-level adaptive	⚠️ Manual configuration required	❌ Uniformly complex	❌ Uniformly simple
State Machine	✅ Core design	⚠️ Partially supported	❌ None	⚠️ Simple loop
Downgrade Capability	✅ Supported	❌ Not supported	❌ Not supported	❌ Not supported
Versatility	✅ All tasks	✅ Wide range	⚠️ Specific scenarios	⚠️ Specific scenarios

Unique value: Combination of adaptability and versatility, providing an automatically adjustable infrastructure.

Potential Challenges

• Accuracy of complexity evaluation: Misjudgment leads to resource waste or quality degradation
• State explosion: Poorly designed phases and transition rules make management difficult
• Trade-off between latency and cost: Complex level has high latency and cost
• Interpretability: Adaptive decisions need to be transparent

Improvement Directions

• Introduce machine learning to optimize complexity evaluation
• Support user-defined complexity levels
• Add A/B testing framework to compare strategy effects
• Integrate advanced planning algorithms (MCTS, ToT)