Sequential Thinking Multi-Agent System (MAS) 

Overview

• A Coordinating Agent (the Team object in coordinate mode) manages the workflow.

• Specialized Agents (Planner, Researcher, Analyzer, Critic, Synthesizer) handle specific sub-tasks based on their defined roles and expertise.

• Incoming thoughts are actively processed, analyzed, and synthesized by the agent team, not just logged.

• The system supports complex thought patterns, including revisions of previous steps and branching to explore alternative paths.

• Integration with external tools like Exa (via the Researcher agent) allows for dynamic information gathering.

• Robust Pydantic validation ensures data integrity for thought steps.

• Detailed logging tracks the process, including agent interactions (handled by the coordinator).

Key Differences from Original Version (TypeScript)

How it Works (Coordinate Mode)

1. Initiation: An external LLM uses the sequential-thinking-starter prompt to define the problem and initiate the process.

2. Tool Call: The LLM calls the sequentialthinking tool with the first (or subsequent) thought, structured according to the ThoughtData Pydantic model.

3. Validation & Logging: The tool receives the call, validates the input using Pydantic, logs the incoming thought, and updates the history/branch state via AppContext.

4. Coordinator Invocation: The core thought content (along with context about revisions/branches) is passed to the SequentialThinkingTeam's arun method.

5. Coordinator Analysis & Delegation: The Team (acting as Coordinator) analyzes the input thought, breaks it down into sub-tasks, and delegates these sub-tasks to the most relevant specialist agents (e.g., Analyzer for analysis tasks, Researcher for information needs).

6. Specialist Execution: Delegated agents execute their specific sub-tasks using their instructions, models, and tools (like ThinkingTools or ExaTools).

7. Response Collection: Specialists return their results to the Coordinator.

8. Synthesis & Guidance: The Coordinator synthesizes the specialists' responses into a single, cohesive output. This output may include recommendations for revision or branching based on the specialists' findings (especially from the Critic and Analyzer). It also provides guidance for the LLM on formulating the next thought.

9. Return Value: The tool returns a JSON string containing the Coordinator's synthesized response, status, and updated context (branches, history length).

10. Iteration: The calling LLM uses the Coordinator's response and guidance to formulate the next sequentialthinking tool call, potentially triggering revisions or branches as suggested.

Token Consumption Warning

• The Coordinator agent (the Team itself).

• Multiple specialist agents (potentially Planner, Researcher, Analyzer, Critic, Synthesizer, depending on the Coordinator's delegation).

Prerequisites

• Python 3.10+

• Access to a compatible LLM API (configured for agno). The system currently supports:

• Exa API Key (required only if using the Researcher agent's capabilities)

• uv package manager (recommended) or pip.

MCP Server Configuration (Client-Side)

Installation & Setup

1. Clone the repository:

2. Set Environment Variables: Create a .env file in the project root directory or export the variables directly into your environment:Note on Model Selection:

3. Install Dependencies: It's highly recommended to use a virtual environment.

Usage

Sequential Thinking Multi-Agent System (MAS) 

Overview

• A Coordinating Agent (the Team object in coordinate mode) manages the workflow.

• Specialized Agents (Planner, Researcher, Analyzer, Critic, Synthesizer) handle specific sub-tasks based on their defined roles and expertise.

• Incoming thoughts are actively processed, analyzed, and synthesized by the agent team, not just logged.

• The system supports complex thought patterns, including revisions of previous steps and branching to explore alternative paths.

• Integration with external tools like Exa (via the Researcher agent) allows for dynamic information gathering.

• Robust Pydantic validation ensures data integrity for thought steps.

• Detailed logging tracks the process, including agent interactions (handled by the coordinator).

Key Differences from Original Version (TypeScript)

How it Works (Coordinate Mode)

1. Initiation: An external LLM uses the sequential-thinking-starter prompt to define the problem and initiate the process.

2. Tool Call: The LLM calls the sequentialthinking tool with the first (or subsequent) thought, structured according to the ThoughtData Pydantic model.

3. Validation & Logging: The tool receives the call, validates the input using Pydantic, logs the incoming thought, and updates the history/branch state via AppContext.

4. Coordinator Invocation: The core thought content (along with context about revisions/branches) is passed to the SequentialThinkingTeam's arun method.

5. Coordinator Analysis & Delegation: The Team (acting as Coordinator) analyzes the input thought, breaks it down into sub-tasks, and delegates these sub-tasks to the most relevant specialist agents (e.g., Analyzer for analysis tasks, Researcher for information needs).

6. Specialist Execution: Delegated agents execute their specific sub-tasks using their instructions, models, and tools (like ThinkingTools or ExaTools).

7. Response Collection: Specialists return their results to the Coordinator.

8. Synthesis & Guidance: The Coordinator synthesizes the specialists' responses into a single, cohesive output. This output may include recommendations for revision or branching based on the specialists' findings (especially from the Critic and Analyzer). It also provides guidance for the LLM on formulating the next thought.

9. Return Value: The tool returns a JSON string containing the Coordinator's synthesized response, status, and updated context (branches, history length).

10. Iteration: The calling LLM uses the Coordinator's response and guidance to formulate the next sequentialthinking tool call, potentially triggering revisions or branches as suggested.

Token Consumption Warning

• The Coordinator agent (the Team itself).

• Multiple specialist agents (potentially Planner, Researcher, Analyzer, Critic, Synthesizer, depending on the Coordinator's delegation).

Prerequisites

• Python 3.10+

• Access to a compatible LLM API (configured for agno). The system currently supports:

• Exa API Key (required only if using the Researcher agent's capabilities)

• uv package manager (recommended) or pip.

MCP Server Configuration (Client-Side)

Installation & Setup

1. Clone the repository:

2. Set Environment Variables: Create a .env file in the project root directory or export the variables directly into your environment:Note on Model Selection:

3. Install Dependencies: It's highly recommended to use a virtual environment.

Usage

1. Using `uv run` (Recommended):

2. Directly using Python:

`sequentialthinking` Tool Parameters

Interacting with the Tool (Conceptual Example)

1. LLM: Uses a starter prompt (like sequential-thinking-starter) with the problem definition.

2. LLM: Calls sequentialthinking tool with thoughtNumber: 1, the initial thought (e.g., "Plan the analysis..."), an estimated totalThoughts, and nextThoughtNeeded: True.

3. Server: MAS processes the thought. The Coordinator synthesizes responses from specialists and provides guidance (e.g., "Analysis plan complete. Suggest researching X next. No revisions recommended yet.").

4. LLM: Receives the JSON response containing coordinatorResponse.

5. LLM: Formulates the next thought based on the coordinatorResponse (e.g., "Research X using available tools...").

6. LLM: Calls sequentialthinking tool with thoughtNumber: 2, the new thought, potentially updated totalThoughts, nextThoughtNeeded: True.

7. Server: MAS processes. The Coordinator synthesizes (e.g., "Research complete. Findings suggest a flaw in thought #1's assumption. RECOMMENDATION: Revise thought #1...").

8. LLM: Receives the response, notes the recommendation.

9. LLM: Formulates a revision thought.

10. LLM: Calls sequentialthinking tool with thoughtNumber: 3, the revision thought, isRevision: True, revisesThought: 1, nextThoughtNeeded: True.

11. ... and so on, potentially branching or extending the process as needed.

Tool Response Format

Logging

• Logs are written to ~/.sequential_thinking/logs/sequential_thinking.log by default. (Configuration might be adjustable in the logging setup code).

• Uses Python's standard logging module.

• Includes a rotating file handler (e.g., 10MB limit, 5 backups) and a console handler (typically INFO level).

• Logs include timestamps, levels, logger names, and messages, including structured representations of thoughts being processed.

Development

1. Clone the repository: (As in Installation)

2. Set up Virtual Environment: (Recommended)

3. Install Dependencies (including dev): Ensure your requirements-dev.txt or pyproject.toml specifies development tools (like pytest, ruff, black, mypy).

4. Run Checks: Execute linters, formatters, and tests (adjust commands based on your project setup).

5. Contribution: (Consider adding contribution guidelines: branching strategy, pull request process, code style).

License

Sequential Thinking Multi-Agent System (MAS) 

Overview

• A Coordinating Agent (the Team object in coordinate mode) manages the workflow.

• Specialized Agents (Planner, Researcher, Analyzer, Critic, Synthesizer) handle specific sub-tasks based on their defined roles and expertise.

• Incoming thoughts are actively processed, analyzed, and synthesized by the agent team, not just logged.

• The system supports complex thought patterns, including revisions of previous steps and branching to explore alternative paths.

• Integration with external tools like Exa (via the Researcher agent) allows for dynamic information gathering.

• Robust Pydantic validation ensures data integrity for thought steps.

• Detailed logging tracks the process, including agent interactions (handled by the coordinator).

Key Differences from Original Version (TypeScript)

How it Works (Coordinate Mode)

1. Initiation: An external LLM uses the sequential-thinking-starter prompt to define the problem and initiate the process.

2. Tool Call: The LLM calls the sequentialthinking tool with the first (or subsequent) thought, structured according to the ThoughtData Pydantic model.

3. Validation & Logging: The tool receives the call, validates the input using Pydantic, logs the incoming thought, and updates the history/branch state via AppContext.

4. Coordinator Invocation: The core thought content (along with context about revisions/branches) is passed to the SequentialThinkingTeam's arun method.

5. Coordinator Analysis & Delegation: The Team (acting as Coordinator) analyzes the input thought, breaks it down into sub-tasks, and delegates these sub-tasks to the most relevant specialist agents (e.g., Analyzer for analysis tasks, Researcher for information needs).

6. Specialist Execution: Delegated agents execute their specific sub-tasks using their instructions, models, and tools (like ThinkingTools or ExaTools).

7. Response Collection: Specialists return their results to the Coordinator.

8. Synthesis & Guidance: The Coordinator synthesizes the specialists' responses into a single, cohesive output. This output may include recommendations for revision or branching based on the specialists' findings (especially from the Critic and Analyzer). It also provides guidance for the LLM on formulating the next thought.

9. Return Value: The tool returns a JSON string containing the Coordinator's synthesized response, status, and updated context (branches, history length).

10. Iteration: The calling LLM uses the Coordinator's response and guidance to formulate the next sequentialthinking tool call, potentially triggering revisions or branches as suggested.

Token Consumption Warning

• The Coordinator agent (the Team itself).

• Multiple specialist agents (potentially Planner, Researcher, Analyzer, Critic, Synthesizer, depending on the Coordinator's delegation).

Prerequisites

• Python 3.10+

• Access to a compatible LLM API (configured for agno). The system currently supports:

• Exa API Key (required only if using the Researcher agent's capabilities)

• uv package manager (recommended) or pip.

MCP Server Configuration (Client-Side)

Installation & Setup

1. Clone the repository:

2. Set Environment Variables: Create a .env file in the project root directory or export the variables directly into your environment:Note on Model Selection:

3. Install Dependencies: It's highly recommended to use a virtual environment.

Usage

1. Using `uv run` (Recommended):

2. Directly using Python:

`sequentialthinking` Tool Parameters

Interacting with the Tool (Conceptual Example)

1. LLM: Uses a starter prompt (like sequential-thinking-starter) with the problem definition.

2. LLM: Calls sequentialthinking tool with thoughtNumber: 1, the initial thought (e.g., "Plan the analysis..."), an estimated totalThoughts, and nextThoughtNeeded: True.

3. Server: MAS processes the thought. The Coordinator synthesizes responses from specialists and provides guidance (e.g., "Analysis plan complete. Suggest researching X next. No revisions recommended yet.").

4. LLM: Receives the JSON response containing coordinatorResponse.

5. LLM: Formulates the next thought based on the coordinatorResponse (e.g., "Research X using available tools...").

6. LLM: Calls sequentialthinking tool with thoughtNumber: 2, the new thought, potentially updated totalThoughts, nextThoughtNeeded: True.

7. Server: MAS processes. The Coordinator synthesizes (e.g., "Research complete. Findings suggest a flaw in thought #1's assumption. RECOMMENDATION: Revise thought #1...").

8. LLM: Receives the response, notes the recommendation.

9. LLM: Formulates a revision thought.

10. LLM: Calls sequentialthinking tool with thoughtNumber: 3, the revision thought, isRevision: True, revisesThought: 1, nextThoughtNeeded: True.

11. ... and so on, potentially branching or extending the process as needed.

Tool Response Format

Logging

• Logs are written to ~/.sequential_thinking/logs/sequential_thinking.log by default. (Configuration might be adjustable in the logging setup code).

• Uses Python's standard logging module.

• Includes a rotating file handler (e.g., 10MB limit, 5 backups) and a console handler (typically INFO level).

• Logs include timestamps, levels, logger names, and messages, including structured representations of thoughts being processed.

Development

1. Clone the repository: (As in Installation)

2. Set up Virtual Environment: (Recommended)

3. Install Dependencies (including dev): Ensure your requirements-dev.txt or pyproject.toml specifies development tools (like pytest, ruff, black, mypy).

4. Run Checks: Execute linters, formatters, and tests (adjust commands based on your project setup).

5. Contribution: (Consider adding contribution guidelines: branching strategy, pull request process, code style).

License