home / skills / supercent-io / skills-template / ohmg

ohmg skill

safe

This skill orchestrates multi-domain agents and cross-agent memory to accelerate complex projects, automate coordination, and observability across frontend,

npx playbooks add skill supercent-io/skills-template --skill ohmg

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.7 KB

---
name: ohmg
description: Ultimate multi-agent framework for Google Antigravity. Orchestrates specialized domain agents (PM, Frontend, Backend, Mobile, QA, Debug) via Serena Memory.
allowed-tools: [Read, Write, Bash, Grep, Glob]
tags: [multi-agent, orchestration, gemini, antigravity, serena-memory, workflow]
platforms: [Gemini, Claude, Codex, Antigravity]
version: 1.0.0
source: first-fluke/oh-my-ag
---

# oh-my-ag (ohmg) - Multi-Agent Orchestrator

## When to use this skill

- Coordinating complex multi-domain projects
- Parallelizing tasks across multiple AI agents (PM, Frontend, Backend, etc.)
- Using Serena Memory for cross-agent state management
- Setting up real-time observability dashboards for agent workflows
- Integrating multi-CLI vendors (Gemini, Claude, Codex) in a single project

---

## 1. Core Concepts

### Specialized Agents
| Agent | Specialization | Triggers |
|-------|---------------|----------|
| **Workflow Guide** | Coordinates complex projects | "multi-domain", "complex project" |
| **PM Agent** | Requirements, task decomposition | "plan", "break down" |
| **Frontend Agent** | React/Next.js, styling | "UI", "component", "styling" |
| **Backend Agent** | API, database, auth | "API", "database", "auth" |
| **Debug Agent** | Bug diagnosis, RCA | "bug", "error", "crash" |

### Serena Memory
Orchestrator writes structured state to `.serena/memories/` for real-time monitoring and cross-agent coordination.

---

## 2. Installation & Setup

### Prerequisites
- **Bun** (CLI and dashboards)
- **uv** (Serena setup)

### Interactive Setup
```bash
bunx oh-my-ag
```
Select project type to install relevant skills to `.agent/skills/`.

### Verification
```bash
bunx oh-my-ag doctor
```

---

## 3. Usage Patterns

### Explicit Coordination
```text
/coordinate
```
PM planning → agent spawning → QA review.

### Spawning Agents via CLI
```bash
# Spawn backend agent for a specific task
oh-my-ag agent:spawn backend "Implement auth API" session-01
```

### Dashboard Monitoring
- Terminal: `bunx oh-my-ag dashboard`
- Web: `bunx oh-my-ag dashboard:web` (http://localhost:9847)

---

## 4. MCP Connection & Bridging

### SSE Mode (Shared Server)
If environment needs stdio-to-http bridging:
```bash
bunx oh-my-ag bridge http://localhost:12341/sse
```

---

## 5. Configuration

Configure per-agent CLI mapping in `.agent/config/user-preferences.yaml`:
```yaml
agent_cli_mapping:
  frontend: gemini
  backend: codex
  pm: claude
  qa: claude
```

---

## Quick Reference

| Command | Action |
|---------|--------|
| `bunx oh-my-ag` | Interactive installer |
| `/setup` | Agent-side configuration |
| `bunx oh-my-ag doctor` | System check & repair |
| `bunx oh-my-ag update` | Update skills |
| `bunx oh-my-ag usage` | Show quota usage |

Overview

This skill is an orchestrator for multi-agent software projects, coordinating specialized domain agents (PM, Frontend, Backend, Mobile, QA, Debug) and managing shared state through Serena Memory. It streamlines parallel work, spawns agents via CLI, and provides real-time observability with terminal and web dashboards. The tool integrates multiple LLM CLIs so you can map each agent to the vendor that best fits the task.

How this skill works

The orchestrator listens for coordination commands and triggers specialized agents to perform domain-specific tasks, using Serena Memory to write structured state files for cross-agent context and monitoring. Agents are spawned from the CLI or dashboard, run tasks in isolated sessions, and report progress and artifacts back into the shared memory directory for real-time inspection. Integration hooks map agents to different LLM CLIs, and an SSE bridge mode enables environments that require stdio-to-HTTP bridging.

When to use it

Coordinating complex, multi-domain engineering projects
Parallelizing work across PM, Frontend, Backend, Mobile, QA, and Debug agents
Maintaining shared, observable state across agents with Serena Memory
Setting up real-time dashboards for agent workflows and progress tracking
Bridging environments that require stdio-to-HTTP (SSE) connectivity

Best practices

Define a clear Workflow Guide prompt to coordinate multi-step runs and handoffs
Map each domain agent to the best-suited LLM CLI in user-preferences.yaml
Keep Serena Memory under versioned control and use structured keys for predictable monitoring
Use the dashboard for high-level observability and the CLI for scripted agent spawning and automated runs
Run bunx oh-my-ag doctor regularly to validate environment and dependencies

Example use cases

Run a single coordinated project: PM decomposes tasks, frontend/backend agents implement features, QA agent validates, Debug agent investigates failures
Parallelize feature work across multiple agents to shorten delivery time while retaining centralized state
Integrate different LLM vendors per role (e.g., Gemini for frontend, Codex for backend, Claude for PM/QA) using the agent_cli_mapping
Deploy a live monitoring setup: start the dashboard to watch .serena/memories/ and follow agent progress
Bridge a CI environment that lacks direct stdio access by using SSE bridge mode

FAQ

How do agents share context and status?

Agents write structured state to the .serena/memories/ directory; other agents and the dashboard read those files to obtain context and status.

Which commands start the dashboard and spawn agents?

Use bunx oh-my-ag dashboard or bunx oh-my-ag dashboard:web for observability, and oh-my-ag agent:spawn <agent> "<task>" <session> to spawn agents from CLI.