DEV Community: Sh4rlock

Why Is SoloEngine the Ideal Implementation of Loop Engineering?

Sh4rlock — Mon, 29 Jun 2026 16:29:17 +0000

Loop Engineering ignited the AI engineering community in June 2026.

But after the explosion, a more practical question emerged: concepts are there, but how to implement?

Boris Cherny writes loops with Claude Code, but he writes configuration files in the terminal. Peter Steinberger builds loops with Codex, but he writes Python scripts. Addy Osmani proposed the six primitives of Loop Engineering, but didn't provide a product for ordinary people.

This creates an awkward situation: the philosophy of Loop Engineering is "let everyone design autonomously running AI systems," but current implementation methods still only allow programmers to participate.

The emergence of SoloEngine changed this situation.

Loop Engineering's Implementation Challenges

Loop Engineering is not "let AI fix it a few more times."

Real Loop Engineering requires 6 steps: trigger condition, input materials, execution actions, verification standards, state recording, and stopping condition. If you can't complete these 6 steps, don't talk about full automation yet.

But completing these 6 steps is almost impossible for non-technical people.

What is the trigger condition? Scheduled task or event-driven? How to organize input materials? Pull GitHub Issues or read Slack messages? How to define execution actions? Call APIs or run bash commands? How to design verification standards? Run test suites or manual review? Where to store state records? Markdown files or database? How to set stopping conditions? Stop when target met or stop when timeout?

Every question requires technical judgment. A lawyer can't write cron expressions. An accountant can't design verification rules. An operations manager can't configure state persistence.

Moreover, Loop Engineering has a practical barrier: token cost. Every retry, every subagent, every verification round costs tokens. A Loop without cost control strategies might burn hundreds of dollars while you sleep. Rahul put it directly on X: Loop Engineering easily hits the cost wall first for people with normal budgets.

There are also limitations on applicable scenarios. Loop Engineering is suitable for scenarios with repetitive tasks, automatable verification, and affordable budgets. Not suitable for architecture rewriting, authentication code, production deployment, or vague product requirements. This means even if you're a programmer, Loop Engineering is not a cure-all.

Why Are Current Solutions on the Market Not Ideal?

Current solutions on the market can be divided into three categories. Each category has obvious shortcomings.

Category 1: Terminal Tools (Claude Code, Codex)

Claude Code and Codex indeed support Loop Engineering. Claude Code has /loop and /goal commands. Codex has Automations and Sub-agents.

But their essence is terminal tools for programmers. You need to write configuration files in the terminal, define Agent roles, and set loop parameters. A lawyer won't open a terminal. An accountant can't write TOML configurations. An operations manager can't define an Agent's system prompt.

They meet the technical requirements of Loop Engineering, but completely fail to meet the "low barrier" requirement.

Category 2: Code Frameworks (LangChain, CrewAI, LangGraph)

These frameworks indeed support multi-Agent collaboration and loop control. LangGraph even models loops as directed graphs, natively supporting parallelism and dynamic routing.

But their essence is Python development frameworks. You need to write code to define Agents, orchestrate processes, and set loop conditions. CrewAI's getting started example is dozens of lines of Python. LangGraph's graph structure needs to be declared in code.

They meet the technical requirements, but fail to meet the "non-programmer accessible" requirement.

Category 3: Low-code Workflow Tools (Dify, n8n, Coze)

These platforms indeed support visual drag-and-drop, with low barriers. Dify has a canvas. n8n has a node editor. Coze has a flow designer.

But their essence is workflow tools, not Loop Engineering platforms. The fundamental difference between workflows and Loop Engineering is: workflows execute predefined paths (A→B→C, if/else condition branches), while Loop Engineering executes dynamic loops (Agent autonomously decides what to do next).

On Dify's canvas, you draw "if A then B, else C." On SoloEngine's canvas, you draw "Agent decides when to do B and when to do C."

They meet the low barrier requirement, but fail to meet the "real Loop Engineering" requirement.

SoloEngine: The Only Platform That Meets All Conditions

SoloEngine is one of the few platforms on the market that can simultaneously meet the three conditions of "low barrier," "real Loop Engineering," and "controllable token cost."

1. Encapsulates the 6 steps of a Loop into visual modules

SoloEngine encapsulates the 6 core steps of Loop Engineering — trigger condition, input materials, execution actions, verification standards, state recording, and stopping condition — all behind the scenes.

You don't need to write cron expressions. You just need to set "every morning at 9 AM" on the canvas. You don't need to design verification rules. You just need to check "all tests pass." You don't need to configure state persistence. The system automatically records the state of each loop, supporting resuming from breakpoints.

A lawyer builds a contract review Loop. An accountant builds a financial report analysis Loop. An operations manager builds a competitive monitoring Loop. They don't need to know Python. They just need to define goals, describe processes, and judge result quality.

2. Progressive disclosure, controllable token cost

Loop Engineering has a practical barrier: token cost. Agent loops consume about 4x more tokens than standard chat, and multi-Agent systems can be up to 15x. A Loop without cost control strategies is a disaster in production.

SoloEngine's solution is progressive disclosure.

Each Agent loads required MCP tools and Skills on demand at runtime, instead of stuffing everything into context at once. Specifically: metadata layer (about 100 words) permanently resident, letting the model identify where Skills and MCPs are located; Skill body and MCP tool lists are only loaded when the corresponding scenario is triggered, released after execution is complete; bundled resources are precisely read only when explicitly needed.

This three-layer architecture reduces token consumption by more than 85%. This means even if your Agent team is large and the loop runs many rounds, operating costs remain under control.

Loop Engineering moves from "expensive experiment" to "economical production tool."

3. From Loop to Product

The ultimate goal of Loop Engineering isn't to build a tool just for yourself, but to produce products that can be deployed, distributed, and sold.

SoloEngine supports one-click Agentic AI publishing in v0.3 — packaging the compiled Agent team as a standalone product, deployable for personal use or for distribution and sale.

Your "contract review Loop" can be packaged as SaaS and sold to other law firms. Your "competitive monitoring Loop" can be packaged as a subscription service and sold to e-commerce sellers. Your "content production Loop" can be packaged as a tool and sold to content creator teams.

Loop Engineering upgrades from "personal efficiency tool" to "commercial product factory."

SoloEngine's Unique Architecture

SoloEngine can do this, not because it "has more features," but because its architecture design fundamentally solves the core contradictions of Loop Engineering.

Unified ReAct Engine

All Agents share the same underlying loop logic (Think → Act → Observe → Repeat), with the only difference lying in configuration. Visual design on the canvas is compiled into an Agent DAG through topological sorting, directly converted into an executable Agent team.

What does this mean? It means you don't need to write loop logic for each Agent individually. You just define its role and goal, and SoloEngine automatically handles loop scheduling, state transfer, error recovery, and termination decisions.

Multi-Agent Topology Orchestration

SoloEngine provides 4 preset Agent types: Orchestrator, Planner, Executor, and Custom. Through canvas connections, you can build any topology: Star, Chain, and Mesh.

More importantly, SoloEngine parses hierarchical relationships from the topology, performing connections and SubAgent invocations. The main Agent judges on its own: should it solve this problem itself, or find a professional sub-Agent to help? Every step is a real-time decision based on the current situation — not a predefined A→B→C process.

Multi-Model Unified Interface

Long-term operation of Loop Engineering depends on model stability. But models are evolving; the best model today may not be the best tomorrow.

SoloEngine provides an adapter layer covering commonly used AI models like OpenAI, Anthropic, Ollama, DeepSeek, Qwen, and ChatGLM. Unified interface enables seamless switching.

You can let the "Research Agent" use DeepSeek (strong at long text analysis), the "Code Agent" use Claude (strong at programming), and the "Creative Agent" use GPT-4 (strong at divergent thinking) — each Agent selects the model best suited to it, while you don't need to worry about underlying API differences.

What Can It Actually Do?

SoloEngine is not a concept on PowerPoint. What it can already do includes:

Law Firms: Build a legal affairs Agent team — case analysis Agent automatically extracts key information, legal research Agent automatically matches relevant regulations, document generation Agent automatically generates legal document templates. Lawyers only need to review and sign.

Cross-border E-commerce: Build an operations Agent team — product analysis Agent automatically monitors competitor data, copywriting Agent automatically generates product descriptions, customer service Agent automatically handles customer inquiries. Three Agents collaborate, one person manages 6 online stores.

Indie Developers: Build a full-stack development Agent team — requirements analysis Agent, architecture design Agent, code implementation Agent, and testing Agent. One person completes the work of a whole team.

The common characteristic of these cases is: the users are not programmers, but they can all build their own Loop Engineering systems.

Finally

Loop Engineering is the most important paradigm shift in the AI engineering field in 2026. It liberates humans from the repetitive labor of "driving Agents round by round," letting people focus on designing systems, defining goals, and judging results.

But the implementation of Loop Engineering needs an ideal platform. This platform must simultaneously meet: low barrier, real Loop Engineering, controllable token cost, and productization.

Currently on the market, SoloEngine is one of the few platforms that can simultaneously meet these four conditions.

Claude Code and Codex are powerful tools for programmers, but only belong to programmers. LangChain and CrewAI are frameworks for engineers, but only belong to engineers. Dify and n8n are tools for business people, but only support workflows, not real Loop Engineering.

SoloEngine fills this gap. It transforms Loop Engineering from "programmers' patent" into "something everyone can use."

In 2026, Loop Engineering moves from concept to practice. And SoloEngine is defining the baseline of this practice.

You don't need to wait for the perfect moment. You can clone the repository now, run it locally, and build your first autonomous AI loop.

From "writing prompts" to "designing loops," this transformation doesn't require you to learn Python, doesn't require you to understand ReAct — just requires opening a browser, dragging a few Agents onto the canvas, and clicking run.

🚀 SoloEngine v0.3.0 Release — Checkpoint Mechanism & Message Queue

Sh4rlock — Mon, 29 Jun 2026 15:35:44 +0000

[v0.3.0] - 2026-06-29

🚀 Added

Checkpoint Mechanism — ReActCore introduces three checkpoints during streaming: content_ended (after text content), before_tool_calls (before tool calls), and after_tool_calls (after tool calls), enabling precise interception and state synchronization of the execution flow.
Message Queue System — Added a new MessageQueue class in run.py, supporting async enqueue, drain, and remove operations. Users can now queue messages while the LLM is running; queued messages are sent automatically after the current task completes. The frontend introduces a QueueBar component to display queued messages, with CSS spinning animation, single-line ellipsis, and hover-to-delete functionality.
Queue Message Merging — MessageQueue.drain_all() now merges consecutive messages with the same name into a single message, preventing fragmented user input when multiple queue entries share the same sender.
Queue WebSocket Events — The execution event protocol introduces three new event types: message_queued, queue_drained, and queue_returned (useRunWebSocket.ts). The frontend processes queue state updates in real time.
Stop & Queue Integration — When the user clicks Stop, pending queued messages are returned to the input box via queue_returned. Checkpoint stops cleanly clear the queue and automatically start the next message.
System Notification Messages — Introduced the SystemMessage type (with notification role) to separate error messages from assistant content. Errors are now rendered as independent notification bubbles, no longer embedded within assistant message cards.
tiktoken Real-Time Token Estimation — ReActCore initializes a tiktoken encoder on startup for real-time token counting during streaming. Unknown models fall back to o200k_base.

🔧 Improved

Custom Model Name Auto-Complete — The model name field in ModelManager has been upgraded from Select to AutoComplete, allowing users to type custom model names not in the predefined list.
Message Block Type Unification — Added a new ToolCallsBlock type (message_block.py), unifying the internal tool-call format to an OpenAI-style tool_calls list, replacing the legacy ToolUseBlock.
ReActCore Token Accumulation — Token usage is now estimated chunk-by-chunk via tiktoken and overwritten with the API's precise usage when received. Introduced _get_valid_token_value to uniformly handle None/0/empty values from the API, preventing placeholder values from overwriting accumulated values.
ReActCore Streaming Architecture Refactor — Streaming output structure in react_core.py refactored: each ChatResponse now contains only a single block type (SoloTextBlock or SoloThinkingBlock), replacing the previous pattern of accumulating multiple blocks before yielding. This enables the frontend to precisely handle each type of incremental content.
Message Type Separation — The frontend message type has been unified from LLMMessage[] to Message[] (LLMMessage | SystemMessage). convertToLLMMessages now splits system messages such as error into independent SystemMessage entries rather than reusing LLMMessage. Updated MessageList and RunPanel to render SystemMessage entries.
Unified Error Save Path — Normal and error paths in save_assistant_message now follow the same code path. error is saved as an independent field and no longer written into the data block.
Execution Completion Reliability — on_execution_done now detects empty-collector scenarios (where stream_callback was never triggered) and automatically sets the status to error with detailed LLM failure output. This prevents false "completed" status during silent failures.
Session Creation Flow — createNewSession in runPanelStore now immediately inserts the new session into the sessions array, ensuring the UI reflects the new session without requiring a refresh.
Message Input UX — During LLM execution, the send button stays active to queue new messages instead of showing a blocking warning. The input area supports queuing via WebSocket when isRunning or isWaitingReply is true. The ENTER key now triggers send (queue) as long as the input has content, no longer blocked by isRunning state.
Assistant Message ID Uniqueness — Each execution_start now generates a new msg_asst_${Date.now()} ID, preventing React key conflicts when the queue drain triggers a new assistant message that would otherwise duplicate the previous message ID.
WebSocket Architecture Refactor — websocket_handler.py has been significantly simplified, removing complex grace period and takeover logic. RunContext now owns its own event loop, and the WebSocket only acts as a transport layer with injected callbacks.
Streaming Cancellation Handling — When the user clicks the stop button, aclose() closing the stream in ReActCore no longer raises CancelledError; it is treated as a normal end (breaking out of the loop), avoiding misinterpreting expected stream closure as a cancellation error.
Tool Call Event Management — ToolCallEventManager now uniformly sends tool-call events to the frontend through tool_calls blocks, removing the legacy tool_use block handling logic.
Formatter Simplification — TruncatedFormatterBase removed token_counter and max_tokens parameters along with dead code such as _truncate and _count; the constructor is simplified to a no-arg empty implementation. OpenAIChatFormatter removed the OpenAIMultiAgentFormatter subclass.
Anthropic message_start/message_delta Usage Capture — anthropic_model.py captures input_tokens in the message_start event and accumulated output_tokens in the message_delta event, resolving inaccurate token counts in Anthropic streaming responses.
Anthropic OpenAI Format Conversion — Added a new _convert_openai_to_anthropic_messages static method that converts OpenAI-format messages (tool_calls, reasoning_content) to Anthropic format (tool_use, thinking).
Streaming Tool Call Split — anthropic_model.py and qwen_model.py now yield a separate ChatResponse for each tool_call, enabling precise handling on the frontend.

🗑️ Removed

Removed the backend/SoloAgent/token_counter/ directory, including __init__.py, openai_token_counter.py, and token_base.py. The original functionality has been merged into ReActCore inline accumulation.
backend/SoloAgent/formatter/truncated_formatter_base.py — removed from the exports in __init__.py; the file is preserved but is no longer public API.
Removed dead code OpenAIMultiAgentFormatter from openai_formatter.py.
ToolUseBlock — the message block type was unified from tool_use to tool_calls; the legacy tool_use type is no longer used.
_convert_anthropic_message_to_solo_format function — removed a 99-line Anthropic→Solo format conversion function in anthropic_model.py, replaced by the new OpenAI→Anthropic conversion method.
Reasoning_content injection code removed — Removed the logic that extracts reasoning_content from content in OpenAIChatFormatter, and removed the compatibility code (with DEBUG logs) that forcibly added an empty reasoning_content to messages carrying tool_calls.
Message grouping removed tool_use support — TruncatedFormatterBase._group_messages now only checks tool_calls and tool_result types, removing tool_use compatibility code.

🐛 Fixed

Empty Collector False Report — Fixed a bug where agent.reply caught an exception and returned an error string, but _execute_agent treated the run as completed because the collector was empty. on_execution_done now checks collector.get_chunk_count() > 0 and forces status="error" with the actual LLM error output.
LLM Tokens Missing on Manual Pause — Resolved via tiktoken real-time estimation, which serves as a fallback when API usage is unreachable.
Message Error Display — Error messages are no longer hidden inside assistant content blocks; they are rendered as independent notification-role messages with proper styling and status indicators.
Streaming tool_use Handling — Fixed the parsing and event-sending logic of legacy tool_use blocks in streaming responses, unifying to the tool_calls format.
Filter Thinking-Only Messages in Cache — OpenAIChatFormatter adds filtering logic: when an assistant message has empty content and no tool_calls, it is skipped. This fixes the LLM API error "Input is a zero-length, empty document".
ChunkCollector Type Mapping Correction — ChunkCollector._extract_raw_type in run.py removed recognition of the 'tool_use' type string, unifying the mapping to 'tool_calls'.
aclose No Longer Raises CancelledError — aclose() closing the stream in react_core.py no longer raises CancelledError; it breaks out of the loop and is treated as a normal end, avoiding misinterpreting expected stream closure as a cancellation error.
model._was_cancelled Exception Conversion — When the model closes the stream due to aclose in react_core.py, it is no longer converted to asyncio.CancelledError; it breaks out of the loop and is treated as a normal end, avoiding misinterpreting expected stream closure as a cancellation error.
flow_compiler Early Cancellation Detection — flow_compiler.py adds new logic: immediately after creating the flow, check whether cancel_event is already set, and if so, cancel the flow right away, avoiding wasted HTTP connections.
CompiledFlow Interruption Detection — flow_compiler.py fixed a bug where an interrupted Agent incorrectly returned "completed"; it now returns "stop" status. The output field is no longer filled with error, preventing error pollution of the output.
Windows Clipboard Compatibility — MessageList.tsx unifies on the W3C Clipboard API, ensuring that Windows clipboard history (Win+V) is correctly captured; fixed the issue where clipboard history could not be triggered on Windows.

🤝 Join Us

We're looking for like-minded contributors who share our passion for SoloEngine and Agentic AI. Every contribution — from a typo fix to a full feature — makes SoloEngine better.

📝 Contributing Guide · 💬 Discussions · 📧 Contact Us

SoloEngine: The Best Practice for Loop Engineering, Building Your First Autonomous AI Loop from Scratch

Sh4rlock — Fri, 26 Jun 2026 07:26:11 +0000

In June 2026, Loop Engineering swept through the entire AI engineering community.

Peter Steinberger's tweet with 6.5 million views, Boris Cherny's "I no longer prompt Claude, I write loops," Addy Osmani's official naming — three people, two weeks, one concept from the fringe to the center.

But concepts are concepts. When you actually want to implement Loop Engineering, you discover an awkward reality:

There isn't a single tool on the market that lets you build a production-grade Loop without writing code.

Claude Code and Codex require you to write configuration files in the terminal. LangGraph and CrewAI require you to write Python. Dify and n8n support visual design, but their essence is workflows — predefined paths, not autonomous loops.

This is why SoloEngine was born.

What Is SoloEngine?

SoloEngine is the first low-code Agentic AI development platform, and currently the only product that encapsulates Loop Engineering's complete technology stack into visual modules.

Its core workflow has only three steps:

Canvas Design — Drag Agent nodes in the browser, connect collaborative relationships, configure roles and tools
One-click Compilation — Visual layout is transformed into an Agent DAG through topological sorting
Auto-run — Each Agent runs a ReAct loop (Think → Act → Observe → Repeat), autonomously planning, executing, verifying, and iterating

You don't need to write a single line of code. You don't need to understand technical terms like ReAct, MCP, or SubAgent. You just need to understand your business, and map it out on the canvas.

Why Is SoloEngine the Best Practice for Loop Engineering?

The core of Loop Engineering is designing a system that can run autonomously. Addy Osmani decomposed it into six core primitives: Automations (Automated Scheduling), Worktrees (Work Isolation), Skills (Knowledge Encapsulation), Plugins/Connectors (Tool Connectivity), Sub-agents (Sub-Agent Division of Labor), and Memory (Memory Layer).

SoloEngine encapsulates all six components behind the scenes.

1. Unified ReAct Engine: All Agents Share the Same Loop Logic

One of the biggest engineering challenges of Loop Engineering is how to make multiple Agents collaborate without stepping on each other's toes.

SoloEngine's solution is a unified ReAct architecture. All Agent nodes share the same underlying engine — the "Think → Act → Observe → Repeat" loop. The only difference lies in configuration: some Agents are configured as "Orchestrators," responsible for breaking down goals and assigning tasks; some as "Planners," responsible for formulating execution strategies; some as "Executors," responsible for actual implementation; and some as "Validators," responsible for quality checking.

The visual design on the canvas is compiled and directly converted into an executable Agent team. The same compiler can generate countless team configurations.

2. Multi-Agent Topology Orchestration: From Single Loops to Loop Networks

Loop Engineering isn't a single Agent looping, but a team of Agents collaborating within loops.

SoloEngine provides 4 preset Agent types:

Orchestrator — Breaks down goals like a project manager, assigning tasks to professional sub-Agents
Planner — Responsible for formulating execution strategies, deciding what to do first and what to do next
Executor — Responsible for actual implementation, calling tools, generating content, modifying data
Custom — Completely defined by you

Through canvas connections, you can build any topology: Star (one Orchestrator with multiple Executors), Chain (A finishes and hands over to B, B finishes and hands over to C), Mesh (multiple Agents collaborate with each other). You can freely build different Agent structures to suit your needs.

3. Progressive Disclosure: Making Loop Engineering Economically Feasible with 85%+ Token Savings

Loop Engineering has a practical threshold: token cost.

Agent loops consume about 4x more tokens than standard chat, and multi-Agent systems can be up to 15x. A Loop without cost controls might burn hundreds of dollars while you sleep.

SoloEngine's solution is progressive disclosure.

Each Agent loads required MCP tools and Skills on demand, instead of stuffing everything into context at once. Specifically:

Metadata layer (about 100 words) permanently resident, letting the model identify where Skills and MCPs are located
Skill body and MCP tool lists are only loaded when the corresponding scenario is triggered, released after execution is complete
Bundled resources are precisely read only when explicitly needed

This three-layer architecture reduces token consumption by more than 85%. This means even if your Agent team is large and the loop runs many rounds, operating costs remain under control.

Loop Engineering moves from "expensive experiment" to "economical production tool."

4. MCP Tool Integration: Bringing Loops into Real Business Scenarios

The value of Loop Engineering ultimately depends on how many real business systems it can connect to.

SoloEngine fully supports the MCP (Model Context Protocol), providing three-layer progressive discovery modes:

Standard Discovery — Automatically scans available MCP servers
Deep Discovery — Loads specific tool sets on demand
Custom Discovery — Connects to your self-developed business systems

Through MCP, SoloEngine can connect to GitHub, databases, email systems, office software, e-commerce APIs, social media monitoring — almost any system with an API.

The Loop is no longer "playing in a sandbox," but truly enters your business environment, completing the closed loop from problem discovery to action.

5. Multi-Model Unified Interface: Avoiding Vendor Lock-in

Long-term operation of Loop Engineering depends on model stability. But models evolve; the best model today may not be the best tomorrow.

SoloEngine provides an adapter layer covering commonly used AI models like OpenAI, Anthropic, Ollama, DeepSeek, Qwen, and ChatGLM. Unified interface enables seamless switching.

6. One-click Packaging: From Loop to Product

The ultimate goal of Loop Engineering isn't to build a tool just for yourself, but to produce products that can be deployed, distributed, and sold.

SoloEngine will support one-click Agentic AI publishing in v0.4 — packaging the compiled Agent team as a standalone product, deployable for personal use or for distribution and sale.

Your "Contract Review Loop" can be packaged as SaaS and sold to other law firms. Your "Competitive Monitoring Loop" can be packaged as a subscription service and sold to e-commerce sellers. Your "Content Production Loop" can be packaged as a tool and sold to content creator teams.

Loop Engineering evolves from "personal efficiency tool" to "commercial product factory."

SoloEngine vs Other Solutions

Dimension	Claude Code/Codex	LangChain/CrewAI	Dify/n8n	SoloEngine
Loop Engineering	✓ Supported	✓ Supported	✗ Workflow, not loops	✓ Full Support
No Coding Required	✗ Requires config	✗ Requires Python	✓	✓
Visual Orchestration	✗ Terminal ops	✗ Code config	✓ Partial	✓ Full Canvas
Multi-Agent Collaboration	✓	✓	✗	✓
Progressive Disclosure	✗	✗	✗	✓ 85%+ Token Reduction
One-click Packaging	✗	✗	✗	✓
Open Source License	Varies by tool	Varies by framework	Varies by platform	Apache 2.0

SoloEngine isn't another workflow tool. Unlike Dify, it doesn't let you draw if/else flowcharts. You put Agents on the canvas, set their roles and tools, and they decide what to do and when — this is Agentic AI, this is Loop Engineering.

Finally

But the barrier to implementing Loop Engineering has always been high — until SoloEngine appeared.

SoloEngine encapsulates all of Loop Engineering's six core primitives, unified ReAct engine, multi-Agent topology orchestration, progressive disclosure, MCP tool integration, and multi-model support into a low-code platform. You don't need to write code, just understand your business.

In 2026, Loop Engineering moves from concept to practice. SoloEngine lets everyone participate in this transformation.

You don't need to wait. You can clone the repository now, run it locally, and build your first autonomous AI loop.

The era of Loop Engineering has arrived. The question is: are you standing on the shore, or jumping into the market?

🚀 SoloEngine v0.2.1 Release — LLM Provider Architecture Refactoring, Stop Mechanism & Streaming Output Optimization

Sh4rlock — Mon, 08 Jun 2026 08:29:07 +0000

[v0.2.1] - 2026-06-03

🚀 Added

SubAgent Token Tracking — SubAgent completion events now carry token usage data. The frontend Agent group view displays real-time token consumption per Agent.
Project Isolation — All file-operation endpoints accept an agentic_flow_id parameter, isolating sandbox file systems per flow instance.
MiMo Model Support — Added Xiaomi MiMo as a new LLM provider (LLMProvider.MIMO), implemented via an OpenAI-compatible interface.

🔧 Improved

LLM Stop Mechanism — Removed blocking await response.aclose() calls from individual model layers. Cancellation now raises CancelledError immediately, delegating cleanup to the upper layer and reducing stop-response latency.
LLM Streaming Callbacks — stream_callback no longer buffers chunks until the loop finishes. It now pushes incremental deltas in real time, making intermediate output visible on the frontend as it arrives.
Standalone Provider Configuration — LLM provider settings have been extracted from hardcoded constants into data/config/llm_providers.json. The new get_provider_config() interface supports custom providers, default models, and model lists.
Unified Model Creation Interface — All providers now pass connection parameters through client_kwargs. Added support for frequency_penalty and presence_penalty.
Centralized LLM Configuration — The canvas introduces a configMap for centralized LLM management. Components read config from the store. The /providers API endpoint now returns a color field alongside provider data.
Streaming Data Updates — Streaming output now batches UI updates via requestAnimationFrame instead of direct setState calls. Added duplicate-block detection. useRunWebSocket respects active stop signals.
Message & File-Change Management — Undo operations follow a unified path and clean up associated file_changes and blob records simultaneously. Removed CAS counting — cleanup now follows reference relationships directly.
Canvas Interactions — Canvas connectors now render arrow markers, making flow direction explicit.
Run Panel — SubAgent groups display token counts with improved nested layout. The file browser resets its state automatically when switching projects.
Project Management — get_recent_projects filters directly by agentic_flow_id, correcting data-field mapping issues.

🗑️ Removed

CAS reference-counting methods (ref_count, decrement_ref_count, cleanup_orphan_blobs, etc.)
SoloAgentConfig.memory field
frontend/src/config/providerDefaults.ts — its functionality is now handled by canvasStore.configMap
frontend/src/store/runProjectStore.ts — merged into runPanelStore.ts
Hardcoded model lists, default-model mappings, and redundant string constants from LLMFactory

🤝 Join Us

We're looking for like-minded contributors who share our passion for SoloEngine and Agentic AI. Every contribution — from a typo fix to a full feature — makes SoloEngine better.

📝 Contributing Guide · 💬 Discussions · 📧 Contact Us

🚀 SoloEngine v0.2.0 Release — File Change Tracking & Full Architecture Upgrade

Sh4rlock — Mon, 08 Jun 2026 08:26:04 +0000

[v0.2.0] - 2026-05-25

🚀 Added

File Change Tracking — Real-time display of file creation, modification, and deletion during execution. Includes a file-change diff viewer.
Message Recall — Allows recalling sent messages. All file changes triggered by the recalled message are automatically reverted.
Auto-Scroll Enhancement — Long message lists auto-scroll with a quick-jump button for fast navigation.
Generic Confirmation Dialog — Unified confirmation dialog style across the entire UI.

🔧 Improved

Environment Variable Management — Overhauled .env and environment variable handling for better custom SoloEngine performance.
RunPanel Architecture — Reworked session management, message handling, and file-operation logic. Unified constants and style management for improved maintainability.
WebSocket Message Processing — Refactored the message processing pipeline for greater stability.
SoloAgent Core — Optimized the execution engine, component assembly, all model interfaces, and plugin modules.
Backend Service Layer — Introduced a new service-layer directory. Optimized all API endpoints and core modules.
UI/UX Overhaul — Consolidated style management, removed redundant components, refined navigation structure, and improved card components and Markdown rendering.
Data Storage — Improved database handling, caching mechanisms, and secret management.
Frontend Service Layer — Optimized API services, state management, and local storage for better frontend stability.
Toolset & Protocol Refinement — Added typed protocol definitions and a shared utility toolkit to improve code reusability.

🗑️ Removed

Deprecated LLM tracker, default package management, legacy navbar, timezone settings, and MCP import dialog.
Legacy RunPanel hooks and shared components (cards, file preview, OnlyOffice editor).

🤝 Join Us

We're looking for like-minded contributors who share our passion for SoloEngine and Agentic AI. Every contribution — from a typo fix to a full feature — makes SoloEngine better.

📝 Contributing Guide · 💬 Discussions · 📧 Contact Us

SoloEngine: How to Let AI Run Every Industry

Sh4rlock — Mon, 08 Jun 2026 08:20:17 +0000

As someone with three years of experience in large language model algorithms, agent development, and knowledge base construction, I've recently had a thought: Vibe Coding has emerged in the programming industry simply because programmers know how to write code. Other industries don't have Cursor or Claude Code, not because they lack the need for Agentic AI, but because they don't use LangChain or CrewAI. I wanted to build a tool that lowers the barrier to Agentic AI development to the same simplicity as workflow tools like Dify. Thus, SoloEnginewas born.

SoloEngine, as the first low‑code Agentic AI development platform, fully encapsulates mechanisms such as ReAct, Tool, MCP, Skill, and SubAgent into backend services. When using it, you simply drag an agent onto the canvas, connect collaboration relationships, configure the required tools, and click Run. The backend then automatically compiles everything into your very own Claude Code — planning, execution, and delivery are all autonomously completed by the agent.

Comparison: SoloEngine vs Other Solutions

Feature	Dify, n8n, Zapier	LangChain, CrewAI, LangGraph	SoloEngine
Agentic AI	✗ Scripted workflows only	✓ ReAct / Multi‑Agent	✓ ReAct / Multi‑Agent
No coding required	✓	✗ Python mandatory	✓
Visual orchestration	Partial support	✗	✓ Full canvas experience
Domain experts can build independently	✓ (but workflows are not truly Agentic)	✗	✓
Multi‑agent collaboration	✗	✓	✓

Core Design

For compilation efficiency, all agent nodes adopt a unified ReAct architecture. The platform parses superior‑subordinate relationships through topology, enabling connections and SubAgent calls. The visual design on the canvas is directly compiled into an executable agent team.

At runtime, each agent employs progressive disclosure, loading only the MCPs and Skills it needs on demand — token consumption can be reduced by over 85%.

On the model side, SoloEngine covers commonly used AI models such as OpenAI, Anthropic, Ollama, DeepSeek, Qwen, and Zhipu — a unified interface for seamless switching.

Release Updates

After more than a dozen development iterations, the v0.2 file change tracking and rollback mechanism has been released and is relatively stable. An official release build will be available soon. v0.3's one‑click deployment feature for Agentic AI is in its final stages, allowing compiled agent teams to be packaged as standalone products for self‑deployment or distribution and sales. Meanwhile, long‑term memory and autonomous evolution are also on the roadmap.

Quick Start

git clone https://github.com/Sh4r1ock/SoloEngine.git
cd SoloEngine

# Backend (Python 3.11+)
cd backend
pip install -r requirements.txt
python main.py

# Frontend (Node.js 18+) — run in another terminal
cd frontend 
npm install
npm run dev

Open http://localhost:8991 to build your first agent team.

Get Involved

The project is currently in a phase of rapid iteration. More participants are welcome to help AI drive every industry. We hope that in the future, AI will evolve from Vibe Coding into Vibe Everything.

Project repository: https://github.com/Sh4r1ock/SoloEngine

SoloEngine: Low-Code Agentic AI Development Platform - Create Your Exclusive AI Tools Through Drag-and-Drop

Sh4rlock — Fri, 10 Apr 2026 05:25:27 +0000

SoloEngine: Build Your One-Person Company with SoloEngine. Create your own OpenClaw, Cursor, Trae, or other Agentic AI that are exclusively yours—by simply dragging and dropping

Today, I'd like to introduce an open-source project called SoloEngine. It's a low-code Agentic AI development framework with a core innovation: a complete workflow of Visual Canvas Editing → Compilation → Agentic AI.

🔥 Core Innovation

Canvas Editing → Compilation → Execution:

Drag-and-drop design of multi-Agent workflows on React Flow canvas
One-click compilation into executable Agentic AI systems
Automatic handling of Agent dependencies, concurrent execution, and result aggregation

🚀 Powerful Features

Native Multi-Agent Orchestration: Four preset Agent types (Custom, Orchestrator, Planner, Executor), supporting SubAgent task delegation
Complete MCP Protocol Support: Three-tier progressive discovery mode, saving 85%+ Token compared to traditional methods
Skill System: Progressive disclosure design, allowing AI to load resources on-demand
Rich Tool Ecosystem: 20+ built-in tools covering file operations, search, command execution, network access, and more
Multi-Model Support: Support for mainstream LLMs like OpenAI, Anthropic, Ollama, and Qwen

💡 Why It's Worth Attention

While Agentic AI currently shines in the programming domain, its potential goes far beyond that — don't other industries need AI that can make autonomous decisions and execute tasks independently?

The answer is obviously no.

SoloEngine's goals are:

Enable designers, product managers, and business professionals to build Agentic AI
Lower technical and distribution barriers with visual thinking and one-click packaging
Preserve complete technical depth for professional developers to fully leverage

SoloEngine is also a boon for one-person companies and freelancers!
SoloEngine is particularly suitable for one-person companies, allowing you to:

Freely orchestrate organizational structures that fit your business
Customize Agent hierarchies and task assignments
Create Agentic AI systems that perfectly match your business needs

🤝 Looking for Collaborators!

The project has just released version 0.1.0, with many features still to be improved:

More examples and documentation
Export mechanism and one-click packaging
Integration with external APIs (Lark, Telegram, etc.)
Equal Agent mechanism
i18n multi-language support
Dark mode
Agentic AI operation following
...

If you're interested in Agentic AI, visual programming, or any AI-related content, we welcome you to join us!

GitHub: https://github.com/Sh4r1ock/SoloEngine

Build Your One-Person Company with SoloEngine. Create your own OpenClaw, Cursor, Trae, or other Agentic AI that are exclusively yours—by simply dragging and dropping

Tech Stack: Python 3.11+, FastAPI, React 18.2, TypeScript 5.3

Have any questions or ideas? Feel free to discuss in the comments!