SEAHORSE

Spawn. Orchestrate. Operate.

Seahorse is a visual multi-agent orchestration platform that combines the spawning experience of a real-time strategy game with the daily operational power of a structured workspace. Users spawn teams of AI agents onto a living 2D canvas, then manage them through persistent table views where every agent is a row with its own role, schedule, instructions, and reporting chain.

Dual-Mode Interface

Seahorse operates in two complementary modes:

	Canvas Mode	Table Mode
Primary Use	Spawn new teams, observe real-time execution, intervene during live missions	Configure persistent agents, set recurring schedules, review reports, manage escalations
Visual Metaphor	RTS game battlefield with agents as interactive nodes	Notion-style database with agents as rows in department tables
Interaction	Click agents, drag to reassign, spawn reinforcements, watch data flow	Edit cells, toggle schedules, read manager reports, approve escalations

Core Interaction Loop

1. Spawn (Canvas Mode) — Select a template or describe a mission in natural language. The system spawns agents onto the canvas with animated materialization effects.
2. Watch (Canvas Mode) — Agents work visibly. Task objects flow between agents as glowing data packets along connection lines. Real-time status transitions: idle, working, waiting, complete, error.
3. Command (Canvas Mode) — Click any agent to inspect its current task, output history, and tool usage. Redirect agents, adjust priorities, pause or resume execution.
4. Operate (Table Mode) — Each department becomes a table. Each agent becomes a row with editable columns: role, instructions, schedule/cron, tools, escalation rules, and output destination.
5. Harvest (Both Modes) — Outputs consolidate into deliverables. The manager agent produces summary reports that the human reviews in a dedicated inbox.

Spawn Templates

Pre-configured agent topologies that serve as both the primary entry point and the go-to-market hook:

Template	Manager Agent	Sub-Agents	Default Output
Spawn Your Hedge Fund	Portfolio Manager	Analyst, Risk Assessor, Trader, Compliance Monitor	Portfolio strategy + trade execution log
Spawn Your Tech Team	Engineering Lead	PM, Frontend Dev, Backend Dev, QA Tester	Shipped feature or working prototype
Spawn Your Content Studio	Editorial Director	Researcher, Writer, Editor, SEO Optimizer	Published content package
Spawn Your War Room	Intelligence Chief	Scout, Strategist, Ops Coordinator, Comms Lead	Competitive intelligence brief
Spawn Your Sales Army	Sales Director	Lead Generator, Qualifier, Closer, CRM Ops	Pipeline with active outreach
Spawn Your Research Lab	Principal Investigator	Literature Reviewer, Data Analyst, Synthesizer	Research report with citations
Spawn Your DeFi Ops	Strategy Manager	Yield Scanner, Rebalancer, Risk Monitor, Gas Optimizer	Position management + P&L report
Spawn Your Support Desk	Support Manager	Ticket Triager, Resolver, Escalation Handler, KB Writer	Resolved tickets + knowledge base updates

Architecture

Four-layer architecture, each independently scalable:

Layer	Technology	Responsibility
Canvas (Visual)	React + PixiJS (WebGL), Zustand, WebSocket	Real-time 2D rendering of agent nodes, connections, animations
Workspace (Operational)	React + TanStack Table, Zustand, REST/WebSocket	Department tables, agent configuration, schedule management, inbox
Orchestrator (Backend)	Fastify, PostgreSQL, Redis, BullMQ	Mission pipeline, task routing, inter-agent messaging, state management
Agent Runtime	Isolated containers, LLM API clients	Individual agent execution, tool invocation, context management

Tech Stack

Category	Choice
Runtime	Bun
Package management	Bun workspaces
Frontend bundler	Vite 6
UI components	Shadcn/ui
Backend framework	Fastify 5
ORM	Drizzle
Database	PostgreSQL 17 + pgvector
Cache/Queue	Redis + BullMQ
State management	Zustand 5
Canvas rendering	PixiJS 8
CSS	Tailwind CSS 4

Project Structure

seahorse/
├── apps/
│   ├── app/          # @seahorse/app  — Main SPA (Canvas + Workspace)
│   └── web/          # @seahorse/web  — Landing page
├── packages/
│   ├── api/          # @seahorse/api  — Fastify backend
│   ├── db/           # @seahorse/db   — Drizzle ORM + schema
│   ├── types/        # @seahorse/types — Shared TypeScript types
│   └── ui/           # @seahorse/ui   — Design tokens + Tailwind preset
├── docker-compose.yml
└── package.json

Getting Started

Prerequisites

• Bun (v1.3+)
• Docker (for Postgres + Redis)

Setup

# Start infrastructure
docker compose up -d

# Install dependencies
bun install

# Generate and run database migrations
bun run db:generate
bun run db:migrate

# Seed demo data
bun run db:seed

# Start all services
bun run dev

Dev Services

Service	Port	Description
@seahorse/app	3000	Main app (Vite HMR)
@seahorse/web	3001	Landing page (Vite HMR)
@seahorse/api	4000	API server (Bun watch)

The app at :3000 proxies /api/* and /ws to :4000.

Useful Commands

bun run dev            # Start all services in parallel
bun run type-check     # Type-check all packages
bun run build          # Build all packages
bun run format         # Format with Prettier
bun run db:studio      # Open Drizzle Studio
bun run docker:up      # Start Postgres + Redis
bun run docker:down    # Stop Postgres + Redis

Database Schema

10 tables with pgvector support for agent memory embeddings:

• users — Accounts with tier (free/pro/team)
• departments — Agent team groupings per user
• agents — Core entity with role, type, system prompt, tools, health score
• missions — One-shot and persistent agent tasks
• agent_executions — Run logs with cost and token tracking
• agent_messages — Inter-agent communication protocol
• escalations — Human review queue from manager agents
• outputs — Mission deliverables with quality scores
• templates — Marketplace spawn templates
• agent_memories — Vector embeddings (1536-dim) for agent context

Documentation

See seahorse-dev-spec-v2.pdf for the complete development specification.

License

Proprietary. All rights reserved.