Two-Tier Cognition Framework (TTCF): Building a Predictable and Controllable Cognitive Architecture for LLM Agents

The Two-Tier Cognition Framework (TTCF) addresses the issues of hallucination, drift, and over-interpretation in current LLM agent architectures by strictly separating the high-level cognitive layer and the deterministic execution layer, offering a new approach to building predictable, controllable, and scalable AI agent systems. Its core is to let LLM lead high-level planning (such as intent understanding, task decomposition, tool selection), while atomic, deterministic domain tools handle low-level execution, completely separating the responsibility boundaries between the two.

Current LLM agent architectures face three fundamental challenges:

1. LLM undertakes both high-level and low-level tasks simultaneously, leading to reasoning drift, inconsistency, and hallucination;
2. LLM lacks determinism in performing precise operations, making it unable to reliably complete domain-specific tasks;
3. Existing tools are too general, requiring LLM to do a lot of interpretive work. These issues restrict the reliability and scalability of LLM agents.

TTCF's design is inspired by human cognition (mental planning + physical execution) and is divided into two layers: High-Level Cognitive Layer (Tier1) : Led by LLM, responsible for probabilistic/creative tasks such as intent interpretation, task decomposition, tool selection, parameter generation, execution orchestration, and result verification; Deterministic Execution Layer (Tier2) : Composed of atomic, domain-specific tools with characteristics of atomicity, determinism, non-interpretability, context independence, and testability. Workflow: User intent → LLM planning (call tool + parameters) → Tool execution → Result return → LLM evaluation (continue/terminate).

The core problems solved by TTCF include:

1. Eliminate execution hallucination: Execution is done by deterministic tools, avoiding unpredictable outputs from LLM;
2. Improve testability: Tools are independent and unit-testable, making the system easy to verify and debug;
3. Training-free expansion: Adding new tools means adding new capabilities without fine-tuning LLM;
4. Prevent ad-hoc execution: Strict hierarchical boundaries prevent LLM from bypassing tools and operating on its own.

The TTCF architecture is deeply similar to biological intelligence: LLM is analogous to the cerebral neocortex (abstract reasoning/planning), and the tool layer is analogous to the cerebellum/reflex system (precise and fast execution). This separation allows the system to think complexly while ensuring reliable execution, providing an intuitive basis for the feasibility of the architecture.

Implementing TTCF requires following six principles:

1. Tool atomicity: Single clear operation;
2. Tool determinism: Same input leads to same output;
3. Prohibit LLM from interpreting tool outputs: Use structured data directly;
4. Prohibit LLM from executing domain logic: Encapsulate in tools;
5. High-level cognitive layer is stateless: Decisions are based on current context;
6. Tool isolation: No direct dependencies.

TTCF is currently in the v0.1 draft stage. Future plans include: releasing official specifications, expanding architecture diagrams, developing reference implementations, building example agents, establishing domain tool libraries, formulating standard specifications, developing test suites, and accepting community contributions. The project is open-sourced under the Apache 2.0 license, encouraging academic and industrial applications.

TTCF provides a new perspective for LLM agent architecture design, solving current key problems by separating high-level and low-level responsibilities, and pointing the way to building more reliable and predictable AI systems. With the development of the framework and community participation, it is expected to become an important reference standard for agent architectures.