Hive Mind 🧠

The master mind AI that controls hive of AI. The orchestrator AI that controls AIs. The HIVE MIND. The SWARM MIND.

It is also possible to connect this AI to collective human intelligence, meaning this system can communicate with humans for requirements, expertise, feedback.

Inspired by konard/problem-solving

Why Hive Mind?

Hive Mind is the most autonomous, cloud-ready AI issue solver that eliminates developer babysitting while maintaining human oversight on critical decisions.

Hive Mind is a generalist AI (mini-AGI) capable of working on a wide range of tasks - not just programming. Almost anything that can be done with files in a repository can be automated.

Feature	What It Means For You
No Babysitting	Full autonomous mode with sudo access. AI has creative freedom like a real programmer.
Cloud Isolation	Runs on dedicated VMs or Docker. Easy to restore if broken.
Full Internet + Sudo	AI can install packages, fetch docs, and configure the system as needed.
Pre-installed Toolchain	25GB+ ready: 10 language runtimes, 2 theorem provers, build tools. Can install more.
Token Efficiency	Routine tasks automated in code, so AI tokens focus on creative problem-solving.
Time Freedom	What takes humans 2-8 hours, AI completes each working session in 10-25 minutes. Mass execution of tasks in repository is possible. "The code is written while you sleep."
Scale with Orchestration	Parallel workers feel like a team of developers, all for ~$200/month.
Human Control	AI creates draft PRs - you decide what merges. Quality gates where they matter.
Any Device Programming	Manage AI from any device with `/solve` and `/hive` via Telegram bot. No PC, IDE, or laptop required.
100% Open Source	Unlicense (public domain). Full transparency, no vendor lock-in.

"Compared to Codex for $200, this solution is fire." - User feedback

Cost: Claude MAX subscription (~$200/month, currently 50% off = $400 value) provides almost unlimited usage for Hive Mind - the best value/quality balance on the market.

Hive Mind has high creativity indistinguishable from average programmers. It asks questions if requirements are unclear, and you can clarify on the go via PR comments.

For detailed features and comparisons, see docs/FEATURES.md and docs/COMPARISON.md.

⚠️ WARNING

It is UNSAFE to run this software on your developer machine.

It is recommended to use Docker for installation (both locally and on servers). See the Docker installation section below.

This software uses full autonomous mode of Claude Code, that means it is free to execute any commands it sees fit.

That means it can lead to unexpected side effects.

There is also a known issue of space leakage. So you need to make sure you are able to reinstall your virtual machine to clear space and/or any damage to the virtual machine.

⚠️ CRITICAL: Token and Sensitive Data Security

THIS SOFTWARE CANNOT GUARANTEE ANY SAFETY FOR YOUR TOKENS OR OTHER SENSITIVE DATA ON THE VIRTUAL MACHINE.

There are infinite ways to extract tokens from a virtual machine connected to the internet. This includes but is not limited to:

Claude MAX tokens - Required for AI operations
GitHub tokens - Required for repository access
API keys and credentials - Any sensitive data on the system

IMPORTANT SECURITY CONSIDERATIONS:

Running on a developer machine is ABSOLUTELY UNSAFE
Running on a virtual machine is LESS UNSAFE but still has risks
Even though your developer machine data isn't directly exposed, the VM still contains sensitive tokens
Any token stored on an internet-connected system can potentially be compromised

USE THIS SOFTWARE ENTIRELY AT YOUR OWN RISK AND RESPONSIBILITY.

We strongly recommend:

Using dedicated, isolated virtual machines
Rotating tokens regularly
Monitoring token usage for suspicious activity
Never using production tokens or credentials
Being prepared to revoke and replace all tokens used with this system

Minimum system requirements to run hive.mjs:

1 CPU Core
1 GB RAM
> 4 GB SWAP
50 GB disk space

🚀 Quick Start

Global Installation

Using Bun (Recommended)

bun install -g @link-assistant/hive-mind

Using Node.js

npm install -g @link-assistant/hive-mind

Installing Docker

If you don't have Docker installed yet, follow these steps to install Docker Engine on Ubuntu:

# Install prerequisites
sudo apt update
sudo apt install ca-certificates curl

# Add Docker's official GPG key
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add Docker repository
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

# Install Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Verify installation
sudo docker run hello-world

For other operating systems or detailed instructions, see the official Docker documentation.

Using Docker

Run the Hive Mind using Docker for safer local installation - no manual setup required:

Note: Docker is much safer for local installation and can be used to install multiple isolated instances on a server or Kubernetes cluster. For Kubernetes deployments, see the Helm chart installation section below.

# Pull the latest image from Docker Hub
docker pull konard/hive-mind:latest

# Start hive-mind container
docker run -dit --name hive-mind konard/hive-mind:latest

# Verify container started
docker ps -a

# Enter additional terminal process to do installation
docker exec -it hive-mind /bin/bash

# Inside the container, authenticate with GitHub
gh-setup-git-identity

# Authenticate with Claude
claude

# Optionally set configuration like this:
# Use /config command and set:
# Reduce motion                             true # Will save your ssh trafic, and make Claude Code more responsive (less latency)
# Thinking mode                             false # Anthropic models perform better and cheaper without thinking
# Model                                     haiku # chepear for connection testing manually
# Claude in Chrome enabled by default       false # No need for Chrome support on server

# Optionally test Claude connection
claude -p hi --model haiku

# You might need to update hive-mind and agent to latest versions:
bun install -g @link-assistant/hive-mind
bun install -g @link-assistant/agent

# Now you can use hive and solve commands
solve https://github.com/owner/repo/issues/123

# Or you can run telegram bot:

# Exit from additional bash session
exit

# Attach to main bash process
docker attach hive-mind

# Run bot here

# Press Ctrl + P, Ctrl + Q to detach without destroying the container (no stopping of main bash process)

# --- Persisting auth data across restarts ---

# Extract auth data from a running (or stopped) container to the host:
mkdir -p ~/.hive-mind
docker cp hive-mind:/home/hive/.claude ~/.hive-mind/claude
docker cp hive-mind:/home/hive/.claude.json ~/.hive-mind/claude.json
docker cp hive-mind:/home/hive/.config/gh ~/.hive-mind/gh

# Fix ownership to match the hive user inside the container:
HIVE_UID=$(docker exec hive-mind id -u hive)
chown -R $HIVE_UID:$HIVE_UID ~/.hive-mind/claude ~/.hive-mind/gh
chown $HIVE_UID:$HIVE_UID ~/.hive-mind/claude.json

# On subsequent runs, mount the auth data to keep it between restarts:
docker run -dit \
  --name hive-mind \
  --restart unless-stopped \
  -v /root/.hive-mind/claude:/home/hive/.claude \
  -v /root/.hive-mind/claude.json:/home/hive/.claude.json \
  -v /root/.hive-mind/gh:/home/hive/.config/gh \
  konard/hive-mind:latest

Benefits of Docker:

✅ Pre-configured Ubuntu 24.04 environment
✅ All dependencies pre-installed
✅ Isolated from your host system
✅ Easy to run multiple instances with different GitHub accounts
✅ Consistent environment across different machines

See docs/DOCKER.md for advanced Docker usage.

Stoping and removing docker container

# Attach to main docker process to stop the container
docker attach hive-mind

^C # stop the telegram bot

exit # exit/stop the container

docker ps -a # show list of docker containers
# CONTAINER ID   IMAGE                     COMMAND       CREATED      STATUS                        PORTS     NAMES
# fd0fd4470ec3   konard/hive-mind:latest   "/bin/bash"   5 days ago   Exited (130) 16 seconds ago             hive-mind


df -h # check disk space
# Filesystem      Size  Used Avail Use% Mounted on
# tmpfs           1.2G  1.1M  1.2G   1% /run
# /dev/sda1        96G   87G  9.8G  90% /
# tmpfs           5.9G     0  5.9G   0% /dev/shm
# tmpfs           5.0M     0  5.0M   0% /run/lock
# /dev/sda16      881M  117M  703M  15% /boot
# /dev/sda15      105M  6.2M   99M   6% /boot/efi
# tmpfs           1.2G   12K  1.2G   1% /run/user/0

docker rm hive-mind # remove docker container frees space used by the container, does not delete image

df -h # check disk space (to confirm space is freed)
# Filesystem      Size  Used Avail Use% Mounted on
# tmpfs           1.2G  1.1M  1.2G   1% /run
# /dev/sda1        96G   26G   71G  27% /
# tmpfs           5.9G     0  5.9G   0% /dev/shm
# tmpfs           5.0M     0  5.0M   0% /run/lock
# /dev/sda16      881M  117M  703M  15% /boot
# /dev/sda15      105M  6.2M   99M   6% /boot/efi
# tmpfs           1.2G   12K  1.2G   1% /run/user/0

Helm Installation (Kubernetes) (Experimental)

⚠️ EXPERIMENTAL: The Helm/Kubernetes installation method is experimental and may not be fully stable.

For a more reliable installation, we recommend using Docker instead.

See docs/HELM.md for the full Helm installation instructions and configuration options.

Installation on Ubuntu 24.04 server (Deprecated)

⚠️ DEPRECATED: This installation method is no longer recommended.

We now recommend using Docker for all installations, both on developer machines and servers. Docker provides better isolation, easier management, and consistent environments.

Please use the Docker installation method above. For Kubernetes deployments, see the Helm installation section.

The legacy bare-metal installation instructions have been moved to docs/UBUNTU-SERVER.md for reference.

Core Operations

# Solve using maximum power
solve https://github.com/Veronika89-lang/index.html/issues/1 --attach-logs --verbose --model opus --think max

# Solve GitHub issues automatically
solve https://github.com/owner/repo/issues/123 --model sonnet

# Solve issue with PR to custom branch (manual fork mode)
solve https://github.com/owner/repo/issues/123 --base-branch develop --fork

# Continue working on existing PR
solve https://github.com/owner/repo/pull/456 --model opus

# Resume from Claude session when limit is reached
solve https://github.com/owner/repo/issues/123 --resume session-id

# Start hive orchestration (monitor and solve issues automatically)
hive https://github.com/owner/repo --monitor-tag "help wanted" --concurrency 3

# Monitor all issues in organization
hive https://github.com/microsoft --all-issues --max-issues 10

# Run collaborative review process
review --repo owner/repo --pr 456

# Multiple AI reviewers for consensus
./reviewers-hive.mjs --agents 3 --consensus-threshold 0.8

📋 Core Components

Script	Purpose	Key Features
`solve.mjs` (stable)	GitHub issue solver	Auto fork, branch creation, PR generation, resume sessions, fork support
`hive.mjs` (stable)	AI orchestration & monitoring	Multi-repo monitoring, concurrent workers, issue queue management
`review.mjs` (alpha)	Code review automation	Collaborative AI reviews, automated feedback
`reviewers-hive.mjs` (alpha / experimental)	Review team management	Multi-agent consensus, reviewer assignment
`telegram-bot.mjs` (stable)	Telegram bot interface	Remote command execution, group chat support, diagnostic tools

🔧 solve Options

solve <issue-url> [options]

Most frequently used options:

Option	Alias	Description	Default
`--model`	`-m`	AI model to use (sonnet, opus, haiku)	sonnet
`--think`		Thinking level (low, medium, high, max)	-
`--base-branch`	`-b`	Target branch for PR	(default)

Other useful options:

Option	Alias	Description	Default
`--tool`		AI tool (claude, opencode, codex, agent)	claude
`--verbose`	`-v`	Enable verbose logging	false
`--attach-logs`		Attach logs to PR (⚠️ may expose sensitive data)	false
`--auto-init-repository`		Auto-initialize empty repos (creates README.md)	false
`--help`	`-h`	Show all available options	-

📖 Full options list: See docs/CONFIGURATION.md for all available options including forking, auto-continue, watch mode, and experimental features.

🔧 hive Options

hive <github-url> [options]

Most frequently used options:

Option	Alias	Description	Default
`--model`	`-m`	AI model to use (sonnet, opus, haiku)	sonnet
`--think`		Thinking level (low, medium, high, max)	-
`--all-issues`	`-a`	Monitor all issues (ignore labels)	false
`--once`		Single run (don't monitor continuously)	false

Other useful options:

Option	Alias	Description	Default
`--tool`		AI tool (claude, opencode, agent)	claude
`--concurrency`	`-c`	Number of parallel workers	2
`--skip-issues-with-prs`	`-s`	Skip issues with existing PRs	false
`--verbose`	`-v`	Enable verbose logging	false
`--attach-logs`		Attach logs to PRs (⚠️ may expose sensitive data)	false
`--help`	`-h`	Show all available options	-

📖 Full options list: See docs/CONFIGURATION.md for all available options including project monitoring, YouTrack integration, and experimental features.

🤖 Telegram Bot

The Hive Mind includes a Telegram bot interface (SwarmMindBot) for remote command execution.

🚀 Test Drive

Want to see the Hive Mind in action? Request a free demo or get faster support by messaging the developer directly on Telegram:

Message @drakonard on Telegram

Setup

Get Bot Token
- Talk to @BotFather on Telegram
- Create a new bot and get your token
- Add the bot to your group chat and make it an admin

Configure Environment

# Copy the example configuration
cp .env.example .env

# Edit and add your bot token
echo "TELEGRAM_BOT_TOKEN=your_bot_token_here" >> .env

# Optional: Restrict to specific chats
# Get chat ID using /help command, then add:
echo "TELEGRAM_ALLOWED_CHATS=123456789,987654321" >> .env

Start the Bot
```
hive-telegram-bot
```
Recommended: Capture logs with tee

When running the bot for extended periods, it's recommended to capture logs to a file using tee. This ensures you can review logs later even if the terminal buffer overflows:
```
hive-telegram-bot 2>&1 | tee -a logs/bot-$(date +%Y%m%d).log
```
Or create a logs directory and start with automatic log rotation:
```
mkdir -p logs
hive-telegram-bot 2>&1 | tee -a "logs/bot-$(date +%Y%m%d-%H%M%S).log"
```

Bot Commands

All commands work in group chats only (not in private messages with the bot):

`/solve` - Solve GitHub Issues

/solve <github-url> [options]

Examples:
/solve https://github.com/owner/repo/issues/123 --model sonnet
/solve https://github.com/owner/repo/issues/123 --model opus --think max

Free Models (with --tool agent):
/solve https://github.com/owner/repo/issues/123 --tool agent --model kimi-k2.5-free
/solve https://github.com/owner/repo/issues/123 --tool agent --model minimax-m2.5-free
/solve https://github.com/owner/repo/issues/123 --tool agent --model gpt-5-nano
/solve https://github.com/owner/repo/issues/123 --tool agent --model big-pickle

Free Models via Kilo Gateway (with --tool agent):
/solve https://github.com/owner/repo/issues/123 --tool agent --model kilo/glm-5-free
/solve https://github.com/owner/repo/issues/123 --tool agent --model kilo/glm-4.5-air-free
/solve https://github.com/owner/repo/issues/123 --tool agent --model kilo/deepseek-r1-free

📖 Free Models Guide: See docs/FREE_MODELS.md for comprehensive information about all free models including OpenCode Zen and Kilo Gateway providers.

`/hive` - Run Hive Orchestration

/hive <github-url> [options]

Examples:
/hive https://github.com/owner/repo
/hive https://github.com/owner/repo --all-issues --max-issues 10
/hive https://github.com/microsoft --all-issues --concurrency 3

`/limits` - Show Usage Limits

/limits

Shows:
- CPU usage and load average
- RAM usage (used vs total)
- Disk space usage
- GitHub API rate limits
- Claude usage limits (session and weekly)

`/help` - Get Help and Diagnostic Info

/help

Shows:
- Chat ID (needed for TELEGRAM_ALLOWED_CHATS)
- Chat type
- Available commands
- Usage examples

Features

✅ Group Chat Only: Commands work only in group chats (not private messages)
✅ Full Options Support: All command-line options work in Telegram
✅ Screen Sessions: Commands run in detached screen sessions
✅ Chat Restrictions: Optional whitelist of allowed chat IDs
✅ Diagnostic Tools: Get chat ID and configuration info

Security Notes

Only works in group chats where the bot is admin
Optional chat ID restrictions via TELEGRAM_ALLOWED_CHATS
Commands run as the system user running the bot
Ensure proper authentication (gh auth login, claude-profiles)

🏗️ Architecture

The Hive Mind operates on three layers:

Orchestration Layer (hive.mjs) - Coordinates multiple AI agents
Execution Layer (solve.mjs, review.mjs) - Performs specific tasks
Human Interface Layer - Enables human-AI collaboration

Data Flow

Mode 1: Issue → Pull Request Flow

sequenceDiagram
    participant H as Human
    participant GH as GitHub
    participant AI as AI Agent
    participant HM as Hive Mind

    H->>GH: Creates Issue
    Note over H,GH: Primary human input

    GH->>HM: Issue Available
    HM->>AI: Assigns Issue
    AI->>GH: Analyzes Issue
    AI->>AI: Develops Solution
    AI->>GH: Creates Draft PR

    Note over H,GH: Human decision point
    GH->>H: Notifies PR Created
    H->>GH: Reviews PR

    alt Approve & Merge
        H->>GH: Merges PR
        GH->>HM: PR Merged
    else Request Changes
        H->>GH: Adds Comments
        Note over H,GH: Secondary human input
        GH->>HM: Comments Added
        HM->>AI: Process Feedback
        AI->>GH: Updates PR
    else Close PR
        H->>GH: Closes PR
        GH->>HM: PR Closed
    end

Mode 2: Pull Request → Comments Flow

sequenceDiagram
    participant H as Human
    participant GH as GitHub
    participant AI as AI Agent
    participant HM as Hive Mind

    Note over GH: Existing PR
    H->>GH: Adds Comment
    Note over H,GH: Primary human input

    GH->>HM: New Comment Available
    HM->>AI: Processes Comment
    AI->>GH: Analyzes Feedback
    AI->>AI: Updates Solution
    AI->>GH: Pushes Changes

    Note over H,GH: Human decision point
    GH->>H: Notifies Changes
    H->>GH: Reviews Updates

    alt Approve & Merge
        H->>GH: Merges PR
        GH->>HM: PR Merged
    else More Changes Needed
        H->>GH: Adds More Comments
        Note over H,GH: Continued human input
        GH->>HM: Comments Added
    else Close PR
        H->>GH: Closes PR
        GH->>HM: PR Closed
    end

📖 For comprehensive data flow documentation including human feedback integration points, see docs/flow.md

📊 Usage Examples

Automated Issue Resolution

# Solve issue (automatically forks if no write access)
solve https://github.com/owner/repo/issues/123 --model opus

# Manual fork and solve issue (works for both public and private repos)
solve https://github.com/owner/repo/issues/123 --fork --model opus

# Continue work on existing PR
solve https://github.com/owner/repo/pull/456 --verbose

# Solve with detailed logging and solution attachment
solve https://github.com/owner/repo/issues/123 --verbose --attach-logs

# Dry run to see what would happen
solve https://github.com/owner/repo/issues/123 --dry-run

Multi-Repository Orchestration

# Monitor single repository with specific label
hive https://github.com/owner/repo --monitor-tag "bug" --concurrency 4

# Monitor all issues in an organization
hive https://github.com/microsoft --all-issues --max-issues 20 --once

# Monitor user repositories with high concurrency
hive https://github.com/username --all-issues --concurrency 8 --interval 120

# Skip issues that already have PRs
hive https://github.com/org/repo --skip-issues-with-prs --verbose

# Auto-cleanup temporary files
hive https://github.com/org/repo --auto-cleanup --concurrency 5

Session Management

# Resume when Claude hits limit
solve https://github.com/owner/repo/issues/123 --resume 657e6db1-6eb3-4a8d

# Continue session interactively in Claude Code
(cd /tmp/gh-issue-solver-123456789 && claude --resume session-id)

🔍 Monitoring & Logging

Find resume commands in logs:

grep -E '\(cd /tmp/gh-issue-solver-[0-9]+ && claude --resume [0-9a-f-]{36}\)' hive-*.log

🔧 Configuration

Authentication:

gh auth login - GitHub CLI authentication
claude-profiles - Claude authentication profile migration to server

OpenRouter Integration:

Use OpenRouter to access 500+ AI models from 60+ providers with a single API key. See docs/OPENROUTER.md for setup instructions covering both Claude Code CLI and @link-assistant/agent.

Environment Variables & Advanced Options:

For comprehensive configuration including environment variables, timeouts, retry limits, Telegram bot settings, YouTrack integration, and all CLI options, see docs/CONFIGURATION.md.

🐛 Reporting Issues

Hive Mind Issues

If you encounter issues with Hive Mind (this project), please report them on our GitHub Issues page:

Repository: https://github.com/link-assistant/hive-mind
Issues: https://github.com/link-assistant/hive-mind/issues

Claude Code CLI Issues

If you encounter issues with the Claude Code CLI itself (e.g., claude command errors, installation problems, or CLI bugs), please report them to the official Claude Code repository:

Repository: https://github.com/anthropics/claude-code
Issues: https://github.com/anthropics/claude-code/issues

🛡️ File Size Enforcement

All documentation files are automatically checked:

find docs/ -name "*.md" -exec wc -l {} + | awk '$1 > 1000 {print "ERROR: " $2 " has " $1 " lines (max 1000)"}'

Server diagnostics

Identify screens that are parents of processes that eating the resources

TARGETS="62220 65988 63094 66606 1028071 4127023"

# build screen PID -> session name map
declare -A NAME
while read -r id; do spid=${id%%.*}; NAME[$spid]="$id"; done \
  < <(screen -ls | awk '/(Detached|Attached)/{print $1}')

# check each PID's environment for STY and map back to session
for p in $TARGETS; do
  sty=$(tr '\0' '\n' < /proc/$p/environ 2>/dev/null | awk -F= '$1=="STY"{print $2}')
  if [ -n "$sty" ]; then
    spid=${sty%%.*}
    echo "$p  ->  ${NAME[$spid]:-$sty}"
  else
    echo "$p  ->  (no STY; not from screen or env cleared / double-forked)"
  fi
done

Show details about the proccess

procinfo() {
  local pid=$1
  if [ -z "$pid" ]; then
    echo "Usage: procinfo <pid>"
    return 1
  fi
  if [ ! -d "/proc/$pid" ]; then
    echo "Process $pid not found."
    return 1
  fi

  echo "=== Process $pid ==="
  # Basic process info
  ps -p "$pid" -o user=,uid=,pid=,ppid=,c=,stime=,etime=,tty=,time=,cmd=

  echo
  # Working directory
  echo "CWD: $(readlink -f /proc/$pid/cwd 2>/dev/null)"

  # Executable path
  echo "EXE: $(readlink -f /proc/$pid/exe 2>/dev/null)"

  # Root directory of the process
  echo "ROOT: $(readlink -f /proc/$pid/root 2>/dev/null)"

  # Command line (full, raw)
  echo "CMDLINE:"
  tr '\0' ' ' < /proc/$pid/cmdline 2>/dev/null
  echo

  # Environment variables
  echo
  echo "ENVIRONMENT (key=value):"
  tr '\0' '\n' < /proc/$pid/environ 2>/dev/null | head -n 20

  # Open files (first few)
  echo
  echo "OPEN FILES:"
  ls -l /proc/$pid/fd 2>/dev/null | head -n 10

  # Child processes
  echo
  echo "CHILDREN:"
  ps --ppid "$pid" -o pid=,cmd= 2>/dev/null
}
procinfo 62220

Maintenance

Enter latest screen

s=$(screen -ls | awk '/Detached/ {print $1; exit}'); echo "Entering $s"; screen -r "$s"; echo "Left $s";

Enter oldest screen

s=$(screen -ls | awk '/Detached/ {last=$1} END{print last}'); echo "Entering $s"; screen -r "$s"; echo "Left $s";

Reboot server.

sudo reboot

That will remove all dangling unused proccesses and screens, which will in turn free the RAM and reduce CPU load. Also reboot may clear all temporary files, so next step can do nothing if reboot was done.

Cleanup disk space.

df -h

rm -rf /tmp

df -h

These commands should be executed under hive user. If you have accidentally removed the /tmp folder itself under root user, you will need to restore it like this:

sudo mkdir -p /tmp
sudo chown root:root /tmp
sudo chmod 1777 /tmp

Close all screens to free up RAM

# close all (Attached or Detached) sessions
screen -ls | awk '/(Detached|Attached)/{print $1}' \
| while read s; do screen -S "$s" -X quit; done

# remove any zombie sockets
screen -wipe

# verify
screen -ls

Top with full arguments of each command

top -c

See the full tree of processes

ps -eo pid,ppid,user,args --forest

or

ps axjf

Kill all commands spawned by specific task

pkill -f gh-issue-solver-1773073065743

That can be done, but not recommended as reboot have better effect.

📄 License

Unlicense License - see LICENSE

🏆 Best Practices

Hive Mind works even better when repositories have strong CI/CD pipelines and clear issue requirements. See:

BEST-PRACTICES.md — Universal prompts, issue writing guidelines, architecture improvement, and subagent patterns
CI-CD-BEST-PRACTICES.md — CI/CD pipeline setup, recommended templates, and enforcement strategies

Key benefits of proper CI/CD:

AI solvers iterate until all checks pass
Consistent quality regardless of human/AI team composition
File size limits ensure code is readable by both AI and humans

Ready-to-use templates are available for JavaScript, Rust, Python, Go, C#, and Java.

🤖 Contributing

This project uses AI-driven development. See CONTRIBUTING.md for human-AI collaboration guidelines.

Name		Name	Last commit message	Last commit date
Latest commit History 4,523 Commits
.changeset		.changeset
.github/workflows		.github/workflows
.husky		.husky
ci-logs		ci-logs
coolify		coolify
data/case-studies		data/case-studies
docs		docs
eslint-rules		eslint-rules
examples		examples
experiments		experiments
helm/hive-mind		helm/hive-mind
scripts		scripts
src		src
tests		tests
.dockerignore		.dockerignore
.env.example		.env.example
.gitignore		.gitignore
.gitpod.Dockerfile		.gitpod.Dockerfile
.gitpod.yml		.gitpod.yml
.jscpd.json		.jscpd.json
.lenv.example		.lenv.example
.prettierignore		.prettierignore
.prettierrc		.prettierrc
CHANGELOG.md		CHANGELOG.md
Dockerfile		Dockerfile
LICENSE		LICENSE
README.md		README.md
analyze-issue.md		analyze-issue.md
claude-runtime.mjs		claude-runtime.mjs
cleanup-test-repos.mjs		cleanup-test-repos.mjs
create-test-repo.mjs		create-test-repo.mjs
cspell.json		cspell.json
do.mjs		do.mjs
docker-compose.yml		docker-compose.yml
docker-restore-auth.sh		docker-restore-auth.sh
docker-solve.sh		docker-solve.sh
eslint.config.mjs		eslint.config.mjs
gitpod-backup-auth.sh		gitpod-backup-auth.sh
gitpod-restore-auth.sh		gitpod-restore-auth.sh
package-lock.json		package-lock.json
package.json		package.json

Folders and files

Latest commit

History

Repository files navigation

Hive Mind 🧠

Why Hive Mind?

⚠️ WARNING

⚠️ CRITICAL: Token and Sensitive Data Security

🚀 Quick Start

Global Installation

Using Bun (Recommended)

Using Node.js

Installing Docker

Using Docker

Stoping and removing docker container

Helm Installation (Kubernetes) (Experimental)

Installation on Ubuntu 24.04 server (Deprecated)

Core Operations

📋 Core Components

🔧 solve Options

🔧 hive Options

🤖 Telegram Bot

🚀 Test Drive

Setup

Bot Commands

/solve - Solve GitHub Issues

/hive - Run Hive Orchestration

/limits - Show Usage Limits

/help - Get Help and Diagnostic Info

Features

Security Notes

🏗️ Architecture

Data Flow

Mode 1: Issue → Pull Request Flow

Mode 2: Pull Request → Comments Flow

📊 Usage Examples

Automated Issue Resolution

Multi-Repository Orchestration

Session Management

🔍 Monitoring & Logging

🔧 Configuration

🐛 Reporting Issues

Hive Mind Issues

Claude Code CLI Issues

🛡️ File Size Enforcement

Server diagnostics

Maintenance

Enter latest screen

Enter oldest screen

Reboot server.

Cleanup disk space.

Close all screens to free up RAM

Top with full arguments of each command

See the full tree of processes

Kill all commands spawned by specific task

📄 License

🏆 Best Practices

🤖 Contributing

About

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases 511

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`/solve` - Solve GitHub Issues

`/hive` - Run Hive Orchestration

`/limits` - Show Usage Limits

`/help` - Get Help and Diagnostic Info

Packages