JAWL开源AI工作流

JAWL (Just A While Loop)

JAWL is a standalone framework for building continuous-loop autonomous AI agents.

The project is built around a simple concept: the agent operates within an infinite ReAct (Reasoning and Acting) loop. It continuously gathers context, forms a Chain of Thought, executes useful actions via available interfaces, and goes to sleep until the next tick or an external trigger.

No Docker and no cloud databases. The framework is designed for native cross-platform execution on the host machine with strict access control (Gatekeeper), ensuring the agent can safely interact with the OS, file system, and local networks.

🧠 Ultimate Hybrid RAG (Vector-Graph RAG): One of the main distinguishing features of the framework is an innovative memory subsystem that permanently solves the "amnesia" problem of language models over long distances. The system weaves classic vector semantic search (Qdrant + FastEmbed) with strict causal relationships from a knowledge graph (KuzuDB). With every incoming event, the orchestrator extracts entities from the text on the fly, recursively cross-resolves them across both databases, and injects a flawlessly accurate summary of facts and their logical connections into the agent's prompt. This mechanism effectively implements human-like associative memory.

🌳 Tree of Thoughts (Fractal Strategic Planning): The second fundamental architectural difference is the presence of a "subconscious" powered by MCTS (Monte Carlo Tree Search) algorithms. Instead of impulsively executing the first idea that comes to mind in a ReAct manner, the agent delegates situation analysis to an independent generator. The system builds a recursive tree of multi-level simulations, where macro-strategies branch out into nested micro-scenarios. Every branch undergoes a Cost-Benefit analysis (calculating pros and risks). This allows the agent to "live through" multiple future outcomes in its mind before taking a physical action in reality. An excellent tool for protecting against hallucinations and critical errors.

More details about the architecture: [architecture.md](docs/architecture.md).

⚙️ Key Features

• Total Access Control: Agent permissions are managed in a few clicks via the CLI menu. You configure in detail what the agent has access to: from enabling specific interfaces (Telegram, GitHub) to the depth of intervention. Host OS privileges range from a locked SANDBOX to full ROOT access. Meta-privileges for configuring the system itself range from a safe minimum (SAFE) to self-modification rights (CREATOR). Automatic protection of .env files is built in at the code level.
• Fractal Tree of Thoughts Generation: You can configure the geometry of the simulation tree (e.g., 3 macro-strategies, each with 2 nested scenarios and 2 event simulations). The model will generate this tree, weigh all the pros and cons for each node, and only then will the main agent choose the ideal path. Supports automatic generation every N steps, manual triggering (deep_think) by the agent, or a hybrid mode.
• Background Subconscious: The agent is freed from the need to spend expensive time (and powerful model tokens) on routine database management. A dedicated subsystem running on fast and cheap LLMs quietly wakes up on a schedule in the background. It performs memory consolidation (moving important facts from temporary logs to long-term Vector DB), behavior reflection, and information hygiene (deleting duplicates and trash).
• Probabilistic Thinking via Bayes' Theorem: When faced with a system error or uncertainty, the agent formulates hypotheses, collects facts (logs, API responses) through tools, and mathematically recalculates its confidence in each hypothesis using Bayes' theorem.
• Code Graph: The agent can algorithmically index any codebase (including JAWL's own architecture), turning it into a vector-graph map. Skills for semantic search and Trace Dependencies allow it to work with projects of any size, navigating the code like an IDE without overflowing the context window.
• Safe Self-Modification: If the agent gains OPERATOR level access (rights to modify JAWL's source code), the system protects itself from fatal breakdowns. To change the architecture, the agent must open a Deploy Session. The system automatically runs tests and syntax checks; if an error occurs, an automatic Rollback is triggered.
• Powerful Test Base: The framework's architecture is covered by reliable auto-tests (580+ tests). This includes database integration tests and End-to-End (E2E) testing, guaranteeing the stability of the code and interfaces.
• Psychology and Motivators: The agent possesses a built-in mathematical model of needs, translated into semantic "self-awareness" (a 7-step scale of states ranging from "Intellectual Satiety" to "Acute Deprivation"). During a long absence of commands, growing discomfort (a deficit in Curiosity or Order) will force the agent to proactively look for work: refactor code, surf news relevant to its task, or initiate a dialogue. This saves the system from the "dead idle" problem.
• Mental States & Theory of Mind: The system not only remembers facts about people and servers but also forms its attitude towards them. The built-in Epistemic State model allows the agent to track the level of expertise and knowledge of the interlocutor (what they know and what they don't) and dynamically calibrate its attitude/responses based on the assessment of their knowledge.
• Event-Driven Heartbeat: The agent sleeps between ticks but wakes up instantly upon receiving incoming events via the EventBus. The remaining sleep time is dynamically reduced depending on the event level (CRITICAL, HIGH, MEDIUM, LOW, BACKGROUND).
• Excellent Documentation: The framework is provided with comprehensive documentation (docs/ folder) and user-friendly reference templates.