convez.ai
AgenteAutomaçãoAvançado
TJ-Neary

HQ Command Center

TJ-Neary/HQ-Command-Center

Coordenação multi-agentes com estado persistente baseada em arquivos

Ver no GitHub
InicialPluginScore · de 0 a 100

Framework baseado em arquivos para gerenciar agentes IA de código através de sessões e projetos com memória persistente e coordenação multi-agentes. Funciona sem servidores ou bancos de dados, apenas com convenções de markdown e MCP servers.

Instalação

$npx convez-ai TJ-Neary/HQ-Command-Center

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 8 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Gerenciar múltiplos agentes IA colaborando no mesmo projeto
  • Manter contexto e memória entre sessões de trabalho
  • Sincronizar trabalho entre ferramentas diferentes (Claude, Gemini, Cursor, etc)
  • Escalabilidade de projetos individuais para portfólio de projetos

Veredito

Framework robusto e battle-tested em produção para coordenação genuína de múltiplos agentes IA. Abordagem inovadora baseada em convenções de arquivo elimina lock-in de plataforma, mas requer compreensão profunda de fluxos de trabalho e disciplina no seguimento de convenções.

README

A tradução para o português deste README ainda está na fila.

_HQ Command Center

Framework Python Agents No Dependencies

_HQ — AI-Augmented Project Command Center

A file-based framework for managing AI coding agents across sessions and projects. Give your agents persistent memory, structured handoffs, and multi-agent coordination — without servers, databases, or platform lock-in.

Built in production, not in theory. This system runs daily across 18 projects, 8 AI agents from 4 competing platforms (Anthropic Claude, OpenAI Codex, Google Gemini, Cursor), and 100+ agent instances — all coordinating through shared markdown files, conventions, and an MCP coordination server.

Get Started in 15 minutes >>>


The Problem

AI coding agents are stateless. Every session starts from zero. If you use multiple AI tools, they can't see each other's work. If you manage multiple projects, each one is an isolated silo.

Most developers compensate by manually re-explaining context, copy-pasting between tools, and keeping track of everything in their head. This works for one agent in one project. It breaks down fast with multiple agents or multiple projects.

The Solution

_HQ solves this with three ideas:

  1. Session bookending — /gogogo loads context at session start, /wrapup saves it at session end. Every session starts informed and ends clean.
  2. File-based state — Agents share state through markdown files (session_memory.md, scratchpad.md, agent_activity.md). Any agent that can read files can participate.
  3. Convention over infrastructure — No databases, no servers, no message queues. Just files and conventions about when to read and write them.

What's Included

Phase 1: Session Management Core (Available Now)

The foundation — how sessions start, how they end, and how state persists between them.

ComponentFileWhat It Does
Session Startupcommands/gogogo.mdLoads context, checks git status, presents priorities, runs extensions
Session Closecommands/wrapup.mdCommits changes, writes session notes, reviews docs, prepares handoff
State Protocolsessions/README.mdExplains the three session files and conventions for reading/writing them
Project InstructionsCLAUDE.md.templateTemplate for AI agent instruction files with extension points
Getting StartedGETTING_STARTED.mdStep-by-step setup guide (15 minutes, no dependencies)

Roadmap

PhaseWhatStatus
Phase 1Session management, file-based state, getting started guideAvailable
Phase 2Standards, templates, project scaffoldingPlanned
Phase 3Multi-agent coordination (domain lanes, handoff protocols)Planned
Phase 4Cross-project sync, drift detection, portfolio managementPlanned
Phase 5Publication pipeline, advisory board, decision recordsPlanned

Each phase builds on the previous one. Phase 1 is self-contained — you can use it without anything from later phases.


How It Works

Session Lifecycle

/gogogo                         /wrapup
   |                               |
   v                               v
Load persona + plan            Git cleanup (commit/push)
   |                               |
Check git status               Write session memory
   |                               |
Read session memory            Update plan (if changed)
   |                               |
Run extensions (optional)      Review documentation
   |                               |
Present priorities             Session summary + handoff
   |
"What should we work on?"

File-Based State Protocol

Three markdown files persist across sessions:

FileWhatWhen ReadWhen Written
session_memory.mdWhat happened in past sessionsSession startSession end
scratchpad.mdQuick handoff notes between agentsBefore major tasksAnytime
agent_activity.mdWho's active, what they're touchingSession startSession start + end

No real-time sync. Agents don't know when another agent writes something — they check when they need to. This is handled by convention:

  • /gogogo reads all three files automatically
  • Mid-session: re-read scratchpad.md before major tasks
  • /wrapup writes to session_memory.md and agent_activity.md

Context Reconstruction

Every session starts clean. The agent doesn't "remember" previous sessions — it reconstructs understanding from files:

  1. persona.md — who am I working with?
  2. plan.md — what are the current priorities?
  3. session_memory.md — what happened recently?
  4. Project's CLAUDE.md — what are the rules for this project?

The conversation is disposable. The files are permanent. This means any agent can pick up where any other agent left off, and switching between AI tools doesn't lose state.


Quick Start

# Copy the framework files into your project
cp -r commands/ your-project/commands/
cp -r sessions/ your-project/sessions/
cp CLAUDE.md.template your-project/CLAUDE.md

# Create local session files (gitignored)
echo "# Session Memory" > your-project/sessions/session_memory.md
echo -e "# Scratchpad

## Open Notes" > your-project/sessions/scratchpad.md
echo -e "# Agent Activity

## Recent Activity" > your-project/sessions/agent_activity.md

# Customize CLAUDE.md with your project info, then:
# Start any AI coding session and type: /gogogo

See GETTING_STARTED.md for the full setup guide.


Production Origin

This isn't a theoretical framework — it's extracted from a system that runs daily:

  • 15 registered projects spanning AI/ML, voice processing, knowledge management, career tools, and web crawling
  • ~9,900 tests across the portfolio, all managed through _HQ's standards distribution
  • 8 AI agents across 4 platforms (Claude, Codex CLI, Codex Extension, Gemini CLI, Antigravity IDE, Cursor IDE, Cursor CLI, Kendra) — 100+ agent instances with shared awareness
  • 77 cataloged assets (standards, guides, templates) distributed with drift detection
  • MCP coordination server — 15 tools for structured multi-agent coordination via stdio transport
  • Verified capability audits — each agent has a self-audited runtime capability file, ensuring accurate task routing
  • Convention-based coordination — no agent has real-time detection, yet handoffs work reliably through file-based protocols

The phased release extracts and genericizes each layer of this system so others can adopt the parts they need.


Core Capabilities (Full System)

These capabilities are available across all phases of the framework:

CapabilityPhaseWhat It Does
Session Continuity1Structured startup/wrapup, persistent memory, cross-session handoff
Multi-Agent Coordination3Domain lanes, handoff protocols, conflict detection, composure management
Standards Distribution2Versioned standards with drift detection, visibility enforcement
Project Scaffolding2Profile-based generation with Jinja2 templates, auto-registration
Cross-Project Communication4Message board with priority levels, bulletin system, status dashboard
Security Pipeline59-phase scanner, pre-publish gate, content classification
Publication Management5Three-tier GitHub model (public/showcase/private), automated readiness
Strategic Advisory Board5Multi-persona deliberation protocol for strategic decisions

Compatibility

Works with any AI coding agent that can read and write files:

AgentStatusNotes
Claude CodeTestedPrimary development platform. Reads CLAUDE.md automatically.
CursorCompatibleUse .cursorrules to reference commands
OpenAI CodexTestedUse AGENTS.md for instruction file
Antigravity IDETestedUse ANTIGRAVITY.md for instruction file
Gemini CLITestedReads GEMINI.md
WindsurfCompatibleUse .windsurfrules for instruction file

The session files and commands are agent-agnostic. Only the instruction file convention differs.


System Design

See ARCHITECTURE.md for the full C4 model with Mermaid.js diagrams covering system context, container architecture, session lifecycle, and multi-agent coordination sequences.


License

Copyright 2026 TJ Neary. All Rights Reserved.

License terms are being finalized. If you're interested in using this framework, open an inquiry.

Ver o original no GitHub

Bom para

Relacionados