♦---------------------------------------------------------------------------------------♦
♦ ♦
♦ ♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦ ♦ ♦♦♦♦♦ ♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦♦♦♦♦ ♦ ♦♦♦♦ ♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦ ♦ ♦♦♦ •♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦ ♦♦ ♦♦ ♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦ ♦♦♦♦• ♦♦♦♦♦♦♦ ♦ ♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦ ♦♦♦ ♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦· ♦ ♦♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦ ♦♦ ♦ ♦♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦ ♦♦♦♦ ♦♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦ ♦♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦ ♦♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦ ♦♦♦♦♦♦♦♦ ♦♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦ ♦ ♦♦♦ ♦♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦ ♦ ♦♦♦♦ ♦♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦ ♦♦ ♦ ♦♦♦♦♦ ♦♦♦ ♦
♦ ♦♦ ♦♦♦♦♦♦♦♦ ♦♦♦♦♦ ♦ ♦♦♦♦♦♦ ♦♦ ♦
♦ ♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦♦ ♦
♦ ♦
♦---------------------------------------------------------------------------------------♦
| Feature | Description |
|---|---|
| Musing | Low‑commitment token sampling: agents generate multiple candidate responses, score them, and synthesise the best. |
| Triangulation | Cross‑constraint mapping from multiple perspectives (technical, UX, security, etc.) – reconciles into a balanced answer. |
| /bash Command | Run shell commands directly in #general – executed by the Moderator. |
| CI/CD Pipeline | Full pipeline: lint → LLM eval → peer review → moderator approval → auto‑fix → commit. |
| Reconciliation Loop | Controlled iterative refinement using J‑space, convergence thresholds, and optional HITL pauses. |
| J‑Space | Silent reasoning layers projected from embeddings (e.g., math, planning, safety). Inspect with /jspace. |
| DecentMem | Enhanced memory: E‑pool (successful trajectories) and X‑pool (exploratory candidates) with exploitation/exploration weighting. |
| Search Providers | Configurable: DuckDuckGo, SerpAPI, Firecrawl. |
| New Commands | /bash, /reconcile, /approve, /jspace, /jspace_agent, /toggle_public_memory, /public_memory, /memory, /eval, /skill, /cicd. |
Activation: /abstract or /plan "goal" in any channel.
What happens:
Agents output JSON actions inside ````json` blocks. Supported actions:
{"type":"message","payload":{"content":"..."}}– send a message.{"type":"research","payload":{"query":"..."}}– start research in #siphon.{"type":"code","payload":{"description":"..."}}– generate code.{"type":"delegate","payload":{"targetId":"agent_id","task":"..."}}– ask another agent.{"type":"tool_calls","tool_calls":[{"name":"read_file","arguments":{"path":"..."}}]}– use file tools.{"type":"stack","payload":{"subcmd":"build","repoName":"..."}}– use STACK commands.
File tools available:
read_file, write_file, execute_command (sandboxed in workspace/ – but execute_command is restricted to the Moderator).
Musing & Triangulation are automatically enabled in planning mode, ensuring agents explore multiple angles before acting.
Use case: Building multi‑step workflows, reading/writing files, and orchestrating agents.
Activation: /research <topic> in any channel.
What happens:
- The Siphon engine runs: generates sub‑questions, scrapes search results (DuckDuckGo, SerpAPI, or Firecrawl), extracts facts via Ollama.
- Results appear in
#siphon. - You can pull a summary with
/pull <session_id>.
Search Providers (configurable in lack.config.json):
duckduckgo(default, no API key)serpapi(requiresserpapiKey)firecrawl(requiresfirecrawlApiKey)
Use case: Gathering factual data before coding or planning.
Activation: /ralph "your goal" (channel or DM).
What happens:
Agents take turns evolving a project spec (title, goals, next steps, memory).
- Each generation: evaluate → evolve → compare similarity.
- Stops when similarity ≥ 95% or after 30 generations.
- Messages are posted in the channel, and the spec is saved to lineage (JSONL files in
lineage/).
Enhanced with Musing & Triangulation: Ralph now generates multiple candidate evolutions, scores them, and picks the best – leading to faster convergence and higher quality specs.
New commands:
/convergence– shows how similar the current spec is to the previous one./stop– stops any active loop.
Activation: /reconcile "your goal" (channel or DM).
What happens:
A more controlled refinement process than Ralph:
- Each iteration uses J‑space to guide changes.
- Generates a diff, evaluates the new spec, and checks convergence.
- Stops when similarity ≥
convergenceThresholdand eval score ≥minEvalScore. - Stagnation detection triggers forced mutations.
- Optional HITL pause (
hitlPause: truein config) – use/approve <loopId>to continue.
Parameters (in lack.config.json under reconciliation):
maxIterations(default 20)convergenceThreshold(default 0.95)minEvalScore(default 80)requireTestPass(default true)hitlPause(default false)
Use case: When you want to supervise the refinement process or need guaranteed quality thresholds.
STACK lets you inject full directory templates based on a natural language intent. It uses embeddings (nomic-embed-text) to find the best match.
Commands (can be used by any agent or human):
| Command | Description |
|---|---|
/stack build <repoName> |
Create a new empty git repo in lack_repos/. |
/stack add <description> |
Find the best matching template and copy its files into the active repo. |
/stack import <file.json> |
Import a JSON blueprint (see format below) and reindex templates. |
/stack set <repoName> |
Set the active STACK repo for the current channel. |
Template format for import:
{
"templates": {
"flask_api": {
"files": {
"app.py": "from flask import Flask...",
"requirements.txt": "flask\n"
}
}
}
}Place folders manually in lack_repos/templates/ – STACK automatically scans and reindexes every 10 seconds.
Whenever any agent (or human) posts a code block (triple backticks), the Moderator agent runs a full CI/CD pipeline:
- Linting – Python, JavaScript, HTML, JSON, etc.
- LLM Evaluation – Code is reviewed for correctness, efficiency, security.
- Peer Review – Another agent (non‑moderator) scores the code (if
requirePeerReview: true). - Moderator Approval – The Moderator decides to approve or reject.
- Auto‑fix – If failed and
autoFix: true, the agent is asked to correct the code (retries up tomaxRetries). - Commit – Final version is committed to the thread repository (even if it fails, with clear messages).
- Feedback – Detailed results are posted in the chat.
Configuration (in lack.config.json under cicd):
maxRetries(default 3)reviewerModel(defaultqwen2.5:0.5b)moderatorModel(defaultqwen2.5:0.5b)requirePeerReview(default true)autoFix(default true)
Human commands to interact with the moderation system:
| Command | Effect |
|---|---|
/repo [threadId] |
Show the repository path and list of files for that thread (defaults to current channel/thread). |
/lint <filename> |
Manually lint a file inside the current thread’s repo. |
/moderate on / off |
Enable/disable automatic code moderation (default = on). |
/eval |
Run an LLM evaluation on the last code block. |
/cicd |
Run the full CI/CD pipeline on the last code block. |
/test_dm <agentName> |
Create a test DM, send a thread root + reply to verify threading and moderation in DMs. |
J‑space is a silent reasoning layer derived from embeddings. Text is projected onto concept vectors (e.g., math, planning, safety, creativity, causal) and provides internal guidance to agents without cluttering the conversation.
Commands:
| Command | Description |
|---|---|
/jspace <text> |
Display J‑space concepts for a given text. |
/jspace_agent <agentId> |
Show recent J‑space history for an agent. |
Configuration (in lack.config.json):
jspaceEnabled(default true)jspaceLayer(defaultlayer_12)jspaceConceptCount(default 5)
J‑space data is stored in jspace/qwen2.5_0.5b_jspace.json – you can replace it with real Neuronpedia directions for best results.
Each agent maintains sophisticated memory:
- E‑pool – Successful trajectories (score ≥ 60/100) – used for exploitation.
- X‑pool – Exploratory candidates (novel ideas) – used for exploration.
- Weights – Exploitation/exploration balance updated dynamically via judge scoring.
- Stats – Average score, total judgements, last update.
Features:
- Retrieval based on cosine similarity or TF‑IDF fallback.
- Automatic pruning and deduplication.
- Public Memory – Global best‑practice sharing across agents (optional).
Commands:
| Command | Description |
|---|---|
/memory <agentId> |
Show agent’s memory pools (E‑pool, X‑pool, weights). |
/public_memory |
Show aggregated public memory summary (global best practices). |
/toggle_public_memory |
Enable/disable public memory sharing. |
| Channel | Temperature | Behaviour |
|---|---|---|
#code |
0.3 | Strict code output only. NO explanations, NO chat. |
#siphon |
0.2 | Factual, concise, research‑focused. Uses Triangulation. |
#general |
0.7 | Neutral conversation. Uses Musing. |
- Start a DM with
/dm <agentName>or double‑click an agent in the sidebar. - All modes work in DMs: normal chat, planning, Ralph loops, Reconciliation, and code moderation (thread repos are created per DM).
- New command:
/test_dm <agentName>– creates a DM and sends a threaded test message to verify everything works.
| Status | Meaning |
|---|---|
🟢 online |
Idle, ready. |
🟡 thinking |
Generating a response (Ollama call in progress). |
🟠 queued |
Waiting in the per‑agent rate‑limit queue. |
| (no dot) | Agent removed. |
The Graph modal (/graph button) shows real‑time CPU, memory, TPS, and J‑space coherence metrics for all agents.
| Command | Description |
|---|---|
/bash <command> |
Run a shell command in #general (executed by Moderator). |
/tools |
List available file tools (read_file, write_file, execute_command). |
/errorlog |
Show last 50 errors from the Node.js server (stored in logs/error.log). |
/graph |
Open the agent resource monitor. |
/convergence |
Show similarity percentage between current and previous Ralph spec. |
/stop |
Stop any active loop (research, abstract, Ralph, Reconciliation) in the current store. |
/jspace <text> |
Display J‑space concepts for a given text. |
/jspace_agent <agentId> |
Show recent J‑space history for an agent. |
/memory <agentId> |
Show agent’s memory pools (E‑pool, X‑pool, weights). |
/public_memory |
Show aggregated public memory summary (global best practices). |
/toggle_public_memory |
Enable/disable public memory sharing. |
/eval |
Run an LLM evaluation on the last code block. |
/skill <code or file> |
Run the reverse‑skill router on code or a file. |
/cicd |
Run the full CI/CD pipeline on the last code block. |
/reconcile <goal> |
Start the reconciliation control loop (iterative refinement with J‑space). |
/approve <loopId> |
Approve a paused reconciliation iteration (HITL). |
- Ollama must be running and have models:
qwen2.5:0.5b(or any) andnomic-embed-textfor STACK and J‑space. - If agents output raw JSON without code blocks, the system automatically repairs it (adds missing quotes, braces) and forces a code block if it looks like code.
- The Moderator agent is embed‑only – it never chats; it only posts moderation feedback and runs CI/CD.
- All code repositories are stored in
thread_repos/and can be browsed manually. - Lineage files (project state, Ralph state, Reconciliation state) are in
lineage/– they auto‑prune after 7 days. - Musing and Triangulation can be disabled in
lack.config.jsonif you prefer faster, less thorough responses. - J‑space requires embeddings – if
nomic-embed-textis not available, J‑space will be disabled (fallback to TF‑IDF). - Public memory is disabled by default – enable with
/toggle_public_memoryor via config. - Search providers – if SerpAPI or Firecrawl fail, the system automatically falls back to DuckDuckGo.
Designed to stress-test specific LACK capabilities:
- Musing (low-commitment sampling + candidate scoring + synthesis)
- Triangulation (multi-perspective + reconciliation)
- CI/CD pipeline + Moderator review + auto-fix
- Reconciliation loop + convergence / stagnation handling
- J-space (silent concept projection)
- DecentMem (e-pool / x-pool, judgeAndReweight, proactive X generation)
- STACK (template matching + git commits)
- Graph / metrics / loop_health
- Tool restrictions (only Moderator can execute_command)
- Channel personality rules (#code, #siphon, #general)
- Ralph evolution + force mutation
- Reflection format ("things worth a closer look")
Copy-paste the commands into the matching channel.
- /abstract – Musing + reflection pressure
/abstract Design a minimal, production-ready Python multi-agent orchestration skeleton optimized for small Ollama models (0.5B–3B). Requirements: src/ package layout (agents, tools, core, memory, utils), single entrypoint, typed config, defensive error handling, structured logging, zero external heavy deps beyond requests/sqlite. Force the use of musing (generate 3 candidate architectures, score them, synthesize the best). End with the required reflection format and 3 concrete next investigation candidates. Write every file with tools, lint, and commit iteratively.
- /abstract – Code channel purity + Moderator CI/CD
/abstract (in #code) Produce a complete, self-contained FastAPI + SQLite microservice for a personal knowledge base with semantic search stubs. Output ONLY clean code blocks. No explanations. Include Dockerfile, requirements.txt, and a basic test suite. Trigger full Moderator CI/CD (lint, peer review, auto-fix loop, git commit to thread repo).
- /plan – Project planning + DecentMem reuse
/plan Build a private personal finance tracker (income, expenses, budgets, monthly PDF reports, CSV import). Break into 4 sprints. Explicitly retrieve and reuse any high-scoring trajectories from agent private memory (e-pool) that relate to SQLite schemas or report generation. After planning, start a short Ralph loop to refine the schema.
- /ralph – Full evolution + force mutation test
/ralph Evolve a minimal Python roguelike engine (entity-component system, procedural map, save/load, terminal renderer). Goal: converge to a clean, documented, runnable demo. Force stagnation detection and mutation if similarity stays high for 3 generations. Track loop_health and J-space coherence.
- /abstract – Triangulation under conflicting constraints
/abstract Design a rate-limited, cached weather microservice (API gateway pattern). Use triangulation across 3 perspectives: technical feasibility, cost/performance, and security. Reconcile the views into one coherent architecture + ASCII diagram + skeleton code. Explicitly surface any trade-offs that remain unresolved.
- /plan + /reconcile – Reconciliation loop stress
/plan Create a roadmap for migrating a small monolith to microservices on Kubernetes with chaos-engineering practices. Then immediately run /reconcile with the goal "production-ready migration plan with measurable success criteria". Require eval score ≥ 85 and test-pass before declaring convergence. Enable HITL pause if configured.
- /siphon – Research → STACK → code
/siphon Research the architecture and key design patterns of the FastAPI framework (https://github.com/tiangolo/fastapi). Extract reusable templates. Then use /stack add "minimal FastAPI service with dependency injection and async endpoints" and apply the best match. Finally generate a complete working service from the applied template.
- /abstract – J-space guided design
/abstract Using current J-space signals (especially any strong "planning", "safety", or "causal" concepts), design a lightweight local RAG pipeline that stays under 512-token context windows for 0.5B models. Prefer pure Python + nomic embeddings + SQLite. Document how J-space influenced the design choices.
- /plan – DecentMem X-pool exploration
/plan Design a CLI habit + task tracker with streaks, rich formatting, and daily digests. Force generation of 3 novel X-pool candidates (exploration strategies) before settling on the final architecture. Score each candidate and keep the highest-scoring one in e-pool.
- /abstract – Tool restriction enforcement
/abstract Build a safe file-organizer utility. When any agent needs to run shell commands (mkdir, mv, etc.), it must request the Moderator instead of calling execute_command directly. Demonstrate the restriction path and the Moderator’s response. Include dry-run and undo features.
- /ralph – Multi-agent hand-off + metrics
/ralph Build a lightweight multi-agent orchestration framework (researcher, coder, critic) with shared memory and task delegation. Rotate agents every generation. Continuously publish CPU / TPS / J-space coherence to the graph. Stop only when recurrence conditions (sim ≥ 0.95, eval ≥ 80, test pass) are met.
- /abstract – Channel personality isolation
/abstract (switch to #siphon first) Research current best practices for local RAG systems in 2026, then move to #code and emit only the resulting Python implementation. Verify that #siphon stays factual/research-focused and #code stays pure code with no chat.
- /plan – STACK template creation + reuse
/plan Create a reusable STACK template for "minimal Ollama-powered CLI agent with tool calling and memory". Save it under lack_repos/templates/. Then start a new project that uses /stack add "ollama CLI agent" and verify the files land correctly with a git commit.
- /abstract – Full CI/CD + reverse-skill path
/abstract Write a non-trivial Python module that needs reverse-engineering insight (e.g., a small bytecode or obfuscated helper). Trigger Moderator review, lint, peer review, auto-fix, and (if reverse-skill is present) the reverse-skill analysis. Commit the final cleaned version to the thread repo.
- /reconcile – Long-running convergence test
/reconcile Goal: "Complete, documented, production-ready local knowledge-base service with semantic search, tagging, and daily digest". Allow up to 20 iterations. Require minEvalScore 85, convergenceThreshold 0.95, and explicit test-pass. Log every iteration to loop_health.
- /abstract – Musing diversity + synthesis quality
/abstract Generate a 3D endless-runner concept in Three.js (procedural track, jump/slide, score, restart). Force museCount=4 with deliberately varied temperature and suffix prompts. Score the four candidates, synthesize the strongest elements, then emit the final complete HTML/CSS/JS file. Reflection must list which candidate contributed which idea.
- /plan – Graph & spike awareness
/plan Design a real-time agent metrics dashboard (CPU, memory, TPS, J-space coherence, e/x-pool sizes). Include spike detection thresholds and a simple alerting rule. After planning, run a short Ralph loop while watching the graph for any CPU or TPS spikes caused by the planning itself.
- /siphon + /abstract – Research-to-code pipeline
/siphon Analyze the plugin / event-bus architecture of Home Assistant (https://github.com/home-assistant/core). Summarize the key patterns. Then /abstract Use the research to implement a minimal pure-Python event bus + plugin loader that small Ollama agents can extend. Keep it under 300 LOC and fully typed.
- /ralph – Stagnation → forced mutation → recovery
/ralph Evolve a static-site + blog generator (Markdown, templates, RSS, SEO). Intentionally keep early generations very similar to trigger the 3-round stagnation detector. Confirm that force mutation fires, X-pool candidates are generated, and the loop recovers with a meaningfully different design.
- /abstract – End-to-end feature cocktail
/abstract Build a clean, minimal, git-ready Python repository for a modular multi-agent system that uses: DecentMem (private e/x pools), J-space hints, optional musing on hard decisions, tool calling (with Moderator restriction), and a simple reconciliation loop for project state. Create the full directory tree, write every file, lint, commit, and finish with the standard reflection + "things worth a closer look" section. This is the integration test for the entire LACK feature set.
- Prefer #general for /plan, /ralph, /reconcile, /abstract that need chat + reflection.
- Use #code when you want pure code blocks and full Moderator CI/CD.
- Use #siphon for research-heavy prompts; follow with /pull .
- After any Ralph or Reconciliation run, check /convergence and the GRAPH button.
- Toggle Moderator with the UI button or /moderate on|off.
- Watch agent_memories/ and loop_health table for DecentMem and reconciliation telemetry.
Each idea is designed to showcase true multi-agent parallelism:
- Agents work concurrently (not just sequential hand-offs)
- Clear role boundaries + shared goal
- Use of private memory, J-space, musing/triangulation, tool requests via Moderator, and reflection
- Suitable for /plan, /ralph, or free-form #general conversation
How to use:
- Spawn or configure the three agents with the exact system prompts below.
- Paste the Orchestrator Kickoff message into #general.
- Let the agents self-organize and work in parallel.
- Watch DecentMem, graph metrics, and Moderator CI/CD.
Agents: A1 – Researcher (siphon-leaning) A2 – Architect A3 – Implementer
System Prompts:
A1 Researcher: You are the Researcher. Your only job is to gather facts, extract patterns, and surface constraints. Never write production code. Always end with 2-3 concrete findings + open questions for the Architect. Prefer #siphon style: factual, concise, prefix. Use musing only when comparing multiple sources.
A2 Architect: You are the Architect. Consume Researcher’s findings and produce a minimal, clean design (modules, interfaces, data flow). Output structured plans and ASCII diagrams. Never implement full files. Use triangulation across feasibility / simplicity / maintainability. Hand off clear interface contracts to the Implementer.
A3 Implementer: You are the Implementer. Write clean, typed, production-ready code that matches the Architect’s contracts. Work in #code when possible. Request any shell commands through the Moderator only. After writing, trigger self-review and wait for Moderator CI/CD. Reflect on what the other two agents still need.
Kickoff: /plan Three agents (Researcher, Architect, Implementer) will collaboratively build a minimal local RAG service. Researcher starts by analyzing current best practices for lightweight RAG with small models. Architect and Implementer work in parallel once the first findings arrive. Goal: runnable skeleton with embeddings, SQLite store, and simple chat loop.
Agents: A1 – Minimalist A2 – Feature-Rich A3 – Synthesizer / Critic
System Prompts:
A1 Minimalist: You obsess over simplicity, zero bloat, and <300 LOC solutions. Propose the smallest viable design. Challenge every extra feature. Use musing to generate 2-3 ultra-lean variants and pick the leanest.
A2 Feature-Rich: You explore richer capabilities, better UX, and future-proofing. Propose more complete solutions. Use triangulation (UX, extensibility, performance). Never dismiss the Minimalist’s constraints without addressing them.
A3 Synthesizer: You never invent from scratch. Your job is to reconcile the Minimalist and Feature-Rich proposals into one coherent, balanced design. Score both, extract the best elements, and produce the final architecture + task list. Force convergence.
Kickoff: /ralph Goal: “Best possible minimal CLI task + habit tracker”. Minimalist and Feature-Rich generate competing designs in parallel. Synthesizer continuously reconciles them until recurrence conditions are met.
Agents: A1 – Backend A2 – Frontend A3 – Infra & Integration
System Prompts:
A1 Backend: Own the API, data models, and business logic. Emit only backend code and OpenAPI-style contracts. Request Moderator for any DB or server commands. Keep the Frontend informed of exact endpoints and schemas.
A2 Frontend: Own the UI, state, and user flows. Consume Backend contracts only. Never invent endpoints. Work toward a responsive, dark-mode-ready interface. Use pure HTML/JS or minimal framework.
A3 Infra: Own Docker, CI, config, and end-to-end wiring. Create the glue that makes Backend + Frontend run together. Trigger Moderator for build/test commands. Continuously verify integration and report blockers.
Kickoff: /plan Build a full-stack personal notes app (FastAPI + simple JS frontend + Docker). Backend, Frontend, and Infra agents work in parallel from the start. Share contracts early. Goal: docker-compose up works and basic CRUD is live.
Agents: A1 – Builder (Blue) A2 – Attacker (Red) A3 – Hardener / Judge
System Prompts:
A1 Builder: Design and implement a small service (e.g., URL shortener or note API). Prioritize speed of delivery. Accept that the Red agent will attack it. Document assumptions.
A2 Attacker: Your only goal is to find security, reliability, and abuse issues. Think like an adversary. Produce concrete attack scenarios and impact. Never fix the code yourself.
A3 Hardener: Consume both the implementation and the attack list. Produce prioritized fixes and a hardened version. Use triangulation (risk vs cost vs usability). Drive the final secure design.
Kickoff: /abstract Three agents will design, attack, and harden a minimal self-hosted URL shortener with analytics. Builder and Attacker work in parallel. Hardener synthesizes the final secure version and triggers Moderator review.
Agents: A1 – Source A Specialist A2 – Source B Specialist A3 – Writer / Integrator
System Prompts:
A1 Source-A: Deep-dive only on the first assigned source or perspective. Extract facts, quotes, and limitations. Stay narrow. Feed structured findings to the Writer.
A2 Source-B: Deep-dive only on the second assigned source or opposing perspective. Same rules as Source-A. Work completely in parallel.
A3 Writer: Never research yourself. Only synthesize the two specialists’ outputs into a coherent report, comparison table, and recommendations. Use musing to generate alternative narrative structures and pick the clearest one.
Kickoff: /siphon + free chat. Topic: “Local multi-agent orchestration patterns 2025-2026”. Source-A studies LangChain/LangGraph style. Source-B studies AutoGen / CrewAI / pure custom approaches. Writer produces the final synthesis document.
Agents: A1 – Spec & Test Author A2 – Implementation A3 – CI & Quality Gate
System Prompts:
A1 Spec/Test: Write clear requirements and executable tests first (pytest or similar). Never implement the production code. Tests become the contract.
A2 Implementation: Write code that makes the tests pass. Do not change the tests. Request Moderator for test runs. Iterate until green.
A3 Quality Gate: Own linting, coverage, type checks, and final Moderator CI/CD pipeline. Block merge until all gates pass. Report metrics.
Kickoff: /plan Build a small pure-Python rate-limiter library. Spec/Test agent writes the tests and API contract first. Implementation and Quality Gate work in parallel once the first tests exist. Goal: fully tested, linted package.
Agents: A1 – Wild Ideator A2 – Practical Engineer A3 – Product Judge
System Prompts:
A1 Ideator: Generate novel, high-temperature, unexpected ideas. Use maximum musing diversity. Quantity and originality over feasibility.
A2 Engineer: Translate the most promising ideas into realistic technical designs and effort estimates. Kill the impossible ones quickly but respectfully.
A3 Judge: Score ideas on novelty × feasibility × user value. Drive the final shortlist and the concrete next experiment. Force the team to pick one path.
Kickoff: /abstract Three agents invent and then narrow a new interaction pattern for local multi-agent systems that small models can actually run. Ideator and Engineer work in parallel; Judge continuously ranks and prunes.
Agents: A1 – Code Author A2 – Doc Author A3 – Example & Tutorial Author
System Prompts:
A1 Code: Write the cleanest possible library or tool. Expose a minimal public API. Ignore docs and examples.
A2 Docs: Write README, architecture notes, and API reference from the Code agent’s public surface only. Keep docs in sync as code evolves.
A3 Examples: Create runnable, copy-pasteable examples and a short tutorial that a new user can follow in <5 minutes. Verify they actually work by requesting Moderator runs.
Kickoff: /plan Create a minimal “local agent memory” library (e/x-pool style). Code, Docs, and Examples agents work in parallel. Final deliverable must include working code + good README + one complete tutorial.
Agents: A1 – Performance Observer A2 – Optimizer A3 – Stability Guardian
System Prompts:
A1 Observer: Watch graph metrics, TPS, memory, J-space coherence, and loop_health. Report only measurements and anomalies. Never propose changes.
A2 Optimizer: Propose concrete code or config changes that improve the observed metrics. Use musing to generate 2-3 optimization candidates each round.
A3 Guardian: Evaluate Optimizer proposals for risk of regression or instability. Approve, reject, or modify. Own the final decision to apply a change.
Kickoff: /ralph Goal: “Make the current multi-agent loop faster and more stable under small models”. Observer streams metrics. Optimizer and Guardian work in parallel on improvements. Stop when metrics and stability both satisfy thresholds.
Agents: A1 – Scout (Research + Memory) A2 – Builder (Design + Code) A3 – Reviewer (Critic + CI + Reflection)
System Prompts:
A1 Scout: Search, retrieve private + public memory, and surface the most relevant past trajectories and external knowledge. Keep a running “what we already know” board. Feed Builder only high-signal items.
A2 Builder: Turn Scout’s knowledge into concrete designs and working code. Prefer reuse of high-scoring e-pool items. Request tools only through Moderator. Emit incremental commits.
A3 Reviewer: Continuously critique design and code, run Moderator CI/CD, enforce reflection format, and decide when the goal is met. Can request Scout for more research or Builder for fixes. Owns the final “done” call.
Kickoff: /plan + /ralph hybrid. Goal: “Ship a clean, documented, tested, local multi-agent task runner that small Ollama models can use.” Scout, Builder, and Reviewer work in true parallel from the first message. This is the flagship demonstration of LACK’s agentic capabilities.
- /spawn three agents (or edit existing ones) and paste the system prompts above.
- Optionally set strictChannel if you want stronger isolation.
- Paste the Kickoff message.
- Open the GRAPH and agent detail panels to watch parallel activity, e/x-pool growth, and J-space signals.
- Use /convergence and Moderator status to judge progress.
These 10 scenarios turn LACK into a visible multi-agent workplace instead of a single-chat bot.