Turbo Flow v4.0 is an agentic development environment organized into several functional layers:

• Interface Layer: Supports Claude Code CLI, Open WebUI (4 instances), and Statusline Pro v4.0.
• Orchestration Layer (Ruflo v3.5): The core engine managing 60+ agents, 215+ MCP tools, AgentDB v3, RuVector WASM, and 3-level model routing.
• Plugin Layer: Includes specialized tools like Agentic QE, Code Intelligence, Test Intelligence, Perf Optimizer, Teammate Plugin, and Gastown Bridge.
• Codebase Intelligence (GitNexus): A knowledge graph that indexes dependencies, call chains, and execution flows, providing impact radius detection via MCP.
• Memory Layer (Three Levels):
  • Beads: Project/Git native JSONL memory for issues and decisions.
  • Native Tasks: Session-based memory (~/.claude/).
  • AgentDB: Persistent memory using RuVector WASM acceleration.
• Isolation Layer: Uses Git Worktrees per agent with automatic PG Vector schema namespacing.
• Infrastructure: Optimized for DevPod, Codespaces, and Rackspace Spot.

When pods are stuck in ContainerCreating with FailedMount events, check the following:

1. Pod Events: Run kubectl describe pod <pod-name> -n <namespace> and look at the Events section.
2. Volume Attachment Conflicts: If a volume is stuck attached to an old node, force delete the old pod: kubectl delete pod <old-pod> -n <namespace> --force --grace-period=0.
3. PVC Status: Verify the PersistentVolumeClaim exists and is bound using kubectl get pvc -n <namespace>.
4. Storage Class: Ensure you are using valid Rackspace storage classes like rackspace-standard or rackspace-ssd via kubectl get storageclass.
5. Manual Detach: If the volume is still attached in the Rackspace Cloud Block Storage panel, manually detach it there.

# Inspect pod events for mounting errors
kubectl describe pod <nombre-pod> -n <namespace> | grep -A 20 Events

# Force delete a pod to release a volume
kubectl delete pod <nombre-pod-antiguo> -n <namespace> --force --grace-period=0

# Check PVCs
kubectl get pvc -n <namespace>

Use these commands for bulk actions within a namespace or across the cluster.

Mass Pod Deletion (Caution): Deletes all pods in Unknown or Error states across all namespaces using jq to parse the status.

kubectl get pods -A --field-selector=status.phase!=Running,status.phase!=Succeeded -o json | \
  jq -r '.items[] | "\(.metadata.namespace) \(.metadata.name)"' | \
  while read ns pod; do kubectl delete pod $pod -n $ns --force --grace-period=0; done

Deployment Management:

# Restart all deployments in a namespace
kubectl rollout restart deployment -n <namespace>

# Scale all deployments to 0 (stop all workloads)
kubectl get deployments -n <namespace> -o name | xargs -I {} kubectl scale {} --replicas=0 -n <namespace>

# Scale all deployments back to 1
kubectl get deployments -n <namespace> -o name | xargs -I {} kubectl scale {} --replicas=1 -n <namespace>

Follow these steps to clone, install, and run your first task in approximately 5 minutes.

1. Clone and Install: Clone the repository, navigate to the devpods directory, and run the appropriate boot script for your OS.
2. Connect to Workspace: Attach to the existing tmux session named workspace.
3. Activate Aliases: Source your .bashrc to enable new command aliases.
4. Start MCP Servers: Initialize the Model Context Protocol (MCP) servers.
5. Execute Task: Use cf-swarm to run an agentic task.

Note: Always work within a tmux session to ensure all new aliases (such as dsp, cf-swarm, cfs, etc.) are active and available.

# 1. Clone and install
git clone https://github.com/marcuspat/turbo-flow-claude.git
cd turbo-flow-claude/devpods
./boot_linux.sh  # or ./boot_macosx.sh

# 2. Connect to tmux
tmux attach -t workspace

# 3. Activate aliases
source ~/.bashrc

# 4. Start MCP servers
af-mcp-start

# 5. Run first task
cf-swarm "Build a simple REST API"

To set up Turbo Flow in a GitHub Codespace, create a boot script, paste the provided setup logic, and execute it. This process clones the repository, extracts the devpods directory to your project root, makes scripts executable, and runs the codespace_setup.sh script.

Steps:

1. Create and open a boot script:

   touch boot.sh && chmod +x boot.sh && vi boot.sh

2. Paste the setup script (see code block below) into boot.sh.
3. Run the script: ./boot.sh.

Setup Script Content:

#!/bin/bash
# Clone the repository
echo "Cloning repository..."
git clone https://github.com/marcuspat/turbo-flow-claude.git

# Check if clone was successful
if [ $? -ne 0 ]; then
    echo "Error: Failed to clone repository"
    exit 1
fi

# Navigate into the cloned directory
cd turbo-flow-claude

# Move devpods directory to parent directory
echo "Moving devpods directory..."
mv devpods ..

# Go back to parent directory
cd ..

# Remove the cloned repository
echo "Removing turbo-flow-claude directory..."
rm -rf turbo-flow-claude

# Make all shell scripts in devpods executable
echo "Making scripts executable..."
chmod +x ./devpods/*.sh

# Run the setup script
echo "Running codespace_setup.sh..."
./devpods/codespace_setup.sh

echo "Script completed!"

Pods may die or enter Unknown status due to node pressure or infrastructure hiccups. To mitigate this, implement resource limits, Pod Disruption Budgets (PDB), and pod anti-affinity to spread pods across different nodes.

# 1. Set proper resource limits on a deployment
kubectl set resources deployment <deployment-name> \
  --limits=cpu=2,memory=4Gi \
  --requests=cpu=1,memory=2Gi \
  -n <namespace>

# 2. Add pod disruption budgets
kubectl create pdb <pdb-name> \
  --selector=app=<your-app> \
  --min-available=1 \
  -n <namespace>

3. Add pod anti-affinity to your deployment spec to spread across nodes

spec:
  template:
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - <your-app>
              topologyKey: kubernetes.io/hostname

To set up Turbo Flow in Google Cloud Shell, use the rapid configuration method by creating and running a boot script. This script clones the repository, moves the devpods directory to the parent folder, and executes the codespace_setup.sh script.

Installation Steps

1. Create a boot script in your Google Cloud Shell:

   touch boot.sh && chmod +x boot.sh && vi boot.sh

2. Paste the configuration script (see code below) into boot.sh.
3. Run the script: bash boot.sh.
4. Wait ~5-10 minutes for completion.
5. Connect to the preconfigured Tmux workspace: tmux attach -t workspace.

#!/bin/bash
# Clonar el repositorio
echo "Clonando repositorio..."
git clone https://github.com/marcuspat/turbo-flow-claude.git

# Verificar si la clonación fue exitosa
if [ $? -ne 0 ]; then
    echo "Error: Falló al clonar repositorio"
    exit 1
fi

# Navegar al directorio clonado
cd turbo-flow-claude

# Mover directorio devpods al directorio padre
echo "Moviendo directorio devpods..."
mv devpods ..

# Regresar al directorio padre
cd ..

# Eliminar el repositorio clonado
echo "Eliminando directorio turbo-flow-claude..."
rm -rf turbo-flow-claude

# Hacer ejecutables todos los scripts shell en devpods
echo "Haciendo scripts ejecutables..."
chmod +x ./devpods/*.sh

# Ejecutar el script de configuración
echo "Ejecutando codespace_setup.sh..."
./devpods/codespace_setup.sh

echo "¡Script completado!"