Control Flow Monitor

An MCP-based autonomous development system where the Control Flow Monitor orchestrates work across specialized agent MCPs, allowing a Large Language Model to continue development work with minimal human intervention.

Compatible MCPs

This project is compatible with the following MCPs:

• gemini-cli-mcp

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                      LLM Instance                             │
│                    (Primary Engineer)                            │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Control Flow Monitor MCP                       │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │ whatsNext() │  │ isComplete()│  │ delegateToAgent()       │  │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
┌──────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ Project Mgr MCP  │ │ Code Review MCP │ │ Future Agents   │
│                  │ │                 │ │                 │
│ - createStory()  │ │ - reviewCommit()│ │ - ...           │
│ - prioritize()   │ │ - reviewFile()  │ │                 │
│ - breakdown()    │ │ - findDupes()   │ │                 │
└──────────────────┘ └─────────────────┘ └─────────────────┘

Process Workflow

The Control Flow Monitor is designed to manage a development workflow by coordinating with other MCPs. Here’s how it works:

1. Initialization: The LLM, acting as the primary engineer, is given a high-level goal.
2. Task Breakdown: The LLM uses the projectManager MCP to break down the goal into smaller, manageable tasks.
3. Prioritization: The projectManager MCP then prioritizes these tasks.
4. Execution: The LLM asks the controlFlowMonitor for the next task using whatsNext().
5. Delegation: The controlFlowMonitor can delegate tasks to other MCPs, such as the codeReview MCP, to perform specific actions like reviewing code.
6. Completion: Once a task is complete, the LLM updates the controlFlowMonitor using isComplete().
7. Iteration: The process repeats until all tasks are completed.

Getting Started

To get started, you can use the following prompts with your LLM:

Initial Prompt

I want to build a CLI tool called "quicknote" that lets users create, list, and search
plain-text notes from the terminal. Notes should be stored as individual markdown files
in a ~/.quicknote directory.

Features needed:
1. `quicknote add "my note content"` - creates a new note with a timestamp
2. `quicknote list` - shows all notes with dates
3. `quicknote search <term>` - finds notes containing the search term
4. `quicknote delete <id>` - removes a note

Please use the project management MCP tools to:
1. Create user stories for each feature
2. Break down the stories into implementable tasks
3. Prioritize the backlog
4. Track progress as you implement each task

Use the control flow monitor to determine what to work on next and update task status
as you complete work. When you finish implementing code, use the code review tools to
check for issues before marking tasks complete.

Start by creating the user stories, then ask me to confirm before beginning implementation.

Follow-up Prompts

• Check status: "What's the current project status? Use the control flow monitor to show me the backlog, completed tasks, and what's next."
• Autonomous workflow: "Create an autonomous workflow for STORY-001 and execute it step by step, updating me after each major milestone."

Installation

Prerequisites

• Go 1.21+
• An LLM with MCP support

Build the MCPs

# Clone the repository
git clone https://github.com/justyntemme/ControlFlowMonitor.git
cd ControlFlowMonitor

# Build all MCPs
cd controlFlowMonitor && go build -o controlFlowMonitor . && cd ..
cd projectManager && go build -o projectManager . && cd ..
cd codeReview && go build -o codeReview . && cd ..

Configure Your LLM

Add to your project's .mcp.json:

{
  "mcpServers": {
    "controlFlowMonitor": {
      "type": "stdio",
      "command": "/Users/{username}/ControlFlowMonitor/controlFlowMonitor/controlFlowMonitor",
      "args": [],
      "env": {}
    },
    "projectManager": {
      "type": "stdio",
      "command": "/Users/{username}/ControlFlowMonitor/projectManager/projectManager",
      "args": [],
      "env": {}
    },
    "codeReview": {
      "type": "stdio",
      "command": "/Users/{username}/ControlFlowMonitor/codeReview/codeReview",
      "args": [],
      "env": {}
    }
  }
}

Then enable the servers in your LLM's settings:

{
  "permissions": {
    "allow": [
      "mcp__controlFlowMonitor__*",
      "mcp__projectManager__*",
      "mcp__codeReview__*"
    ]
  },
  "enabledMcpjsonServers": [
    "controlFlowMonitor",
    "projectManager",
    "codeReview"
  ],
  "enableAllProjectMcpServers": true
}

Note: Replace {username} with your actual username. On macOS/Linux you can find this with whoami.

Available MCP Tools

Control Flow Monitor

| Tool | Description | |------|-------------| | ping | Health check | | getProjectStatus | Returns current project state, tasks, and blockers | | whatsNext | Determines the next action based on project state | | isComplete | Checks if a task or project is complete | | updateTaskStatus | Updates task status (pending/in_progress/completed/blocked) | | getWorkLog | Returns recent work history | | getAvailableAgents | Lists registered agent MCPs | | registerAgent | Registers a new agent MCP | | delegateToAgent | Prepares delegation to another agent | | createWorkflow | Creates an autonomous workflow for a story | | getWorkflowStatus | Returns workflow status | | updateWorkflowStep | Updates a workflow step | | getNextStep | Gets the next step in an active workflow | | getMetrics | Returns operational metrics |

Project Manager

| Tool | Description | |------|-------------| | ping | Health check | | createUserStory | Creates a structured user story | | breakdownStory | Splits a story into tasks | | prioritizeBacklog | Reorders stories by priority | | estimateComplexity | Sets complexity rating | | getBacklog | Returns current backlog | | defineAcceptanceCriteria | Sets acceptance criteria | | updateStoryStatus | Updates story status | | addDependency | Adds dependency between stories |

Code Review

| Tool | Description | |------|-------------| | ping | Health check | | reviewCommit | Reviews a git commit | | reviewFile | Reviews a specific file | | findDuplicates | Detects duplicate code | | checkComplexity | Analyzes cyclomatic complexity | | suggestRefactoring | Identifies refactoring opportunities | | checkSecurityIssues | Scans for security vulnerabilities |

Project State

All project state is stored in the .controlflow/ directory:

.controlflow/
├── state.json      # Current project state (stories, tasks, agents)
├── backlog.json    # Project Manager's backlog
├── workflow.json   # Active workflow state
└── work.log        # History of all actions

Development

Adding a New Agent MCP

1. Create a new directory for your agent
2. Initialize a Go module
3. Implement MCP tools using the official SDK
4. Register with the control flow monitor:

Use the controlFlowMonitor.registerAgent tool to register my new agent
"myAgent" with capabilities ["action1", "action2"]

SDK Reference

All MCPs use the official Go SDK: https://github.com/modelcontextprotocol/go-sdk

import "github.com/modelcontextprotocol/go-sdk/mcp"

server := mcp.NewServer(&mcp.Implementation{
    Name:    "myAgent",
    Version: "1.0.0",
}, nil)

mcp.AddTool(server, &mcp.Tool{
    Name:        "myTool",
    Description: "Does something useful",
}, handleMyTool)

server.Run(context.Background(), &mcp.StdioTransport{})

License

MIT