Summary of "ВО ВСЕ ТЯЖКИЕ: группировка агентов OpenClaw | как это работает"

What this video shows

A practical demo of an agent-based system built on the OpenClaw / Open Clow engine (the creator calls it “the Crab”) used as a multi‑agent team to author, test, anonymize and publish reusable “skills” / products.
The system runs on a Claude $200 subscription (token limits, weekly reset). Example task used ~6% of the weekly limit; one project estimated ≈ $19 in token cost.
Full end‑to‑end workflow is demonstrated live (no cuts): task assignment, skill creation, anonymization/security checks, PDF/MD output, publishing + post/copy generation and accounting of costs.

Heisenberg: the main orchestrator that manages and delegates to other agents.
Agents: full bots with their own memory, prompts, settings and vector/SQL/MD-based storage.
Skills: narrower role/topic behaviors (a “hat” an agent can wear). Skills themselves don’t hold memory; placing them inside topic contexts preserves the interaction chain.
Topics: containers for skills to maintain bounded context without loading the main agent with everything.

Agent memories stored as MD files and in a vector DB / SQLite.
Obsidian used as a personal knowledge base; an agent integrates with Obsidian via CLI to push notes and task history.

A second agent (backup) understands the main agent’s architecture so it can recover or replace it when tokens or services fail.
Watchdog / restart mechanisms auto‑recover from token errors (e.g., 401).

A dedicated security agent runs audits, token checks, config checks, open port and file/token leak detection, and daily/monthly scans.
Agents perform sanitization checks before publishing to ensure zero personal data and no leaked keys.

Agents generate MD files, PDFs, cron reminders, and can autonomously search (e.g., obtain brand‑specific service regulations) to fill templates.
Integration with Obsidian for planning, linking notes and building a task graph.
Cron scheduling and automated reminders (e.g., maintenance reminders from the Auto Mechanic skill).

Heisenberg — main orchestrator / product owner (delegates, final checks).
Walter / Ulter — developer / meticulous implementer (writes code, builds skill files and PDFs).
Saul / Sol — producer / coordinator (organizes pipeline, copy/post creation, quality control).
Jesse Pinkman — marketer (conversion strategy, A/B tests, promotion).
Hank — security auditor (continuous security monitoring and incident alerts).
Skyler — economist / accountant (cost accounting, token usage analysis, bank‑statement processing).
Gustavo Fring — Kaizen / Obsidian manager (planning, linking knowledge in Obsidian, daily task pushes).
Mike Ehrmantraut — fixer / backup agent (system fixer, backup clone of Heisenberg on a separate platform; used to recover/repair the main system).

Create and collect source data and standards (developer reads standards).
Producer (Sol) organizes anonymization and packaging.
Developer (Walter) generates MD files and PDFs, anonymizes data, and runs checks.
Security (Hank) scans for leaks; agent produces clean output.
Producer writes post/copy; marketer handles promotion.
Economist (Skyler) calculates token cost and accounting.
Obsidian agent records tasks/notes and links them into the knowledge graph.

Knows make/year/mileage, service intervals, error codes.
Auto‑collects manufacturer regulations and produces an anonymized PDF + skill package.
Optionally creates cron reminders; can ask users for car specifics during onboarding.

The author builds “guides” (text files / instruction packs) for skills (examples: Family Doctor, Auto Mechanic, auto‑improvement).
Outputs include MD files, PDF product descriptions and GitHub packages for reuse.
A GitHub repo contains wrappers and improvements (adds memory, crons, skills to raw installs).

Tune the main agent thoroughly before casting/creating variants — clean architecture is critical.
Use separate agents for distinct responsibilities — avoid overloading a single agent.
Keep skills in topics to preserve context, but keep agents separate for state/memory isolation.
Create a second agent that knows the main agent’s architecture (for backup and recovery).
Use a security agent to audit tokens, files, open ports and config; maintain daily/monthly checks.
For large files, avoid dumping everything into an agent’s context — place them in a shared folder and give agents access.
Make backups (local / closed GitHub) and provide a recovery agent that can restart or rebuild the main agent.

OpenClaw / Open Clow engine (agent orchestration engine)
Claude (the demo runs on a $200 Claude subscription)
Vector DB / SQLite for memory
MD files and PDFs for artifacts; Obsidian + Obsidian CLI for knowledge management
GitHub (repo with wrappers, skills and improvements)
Cron scheduling, watchdog/restart mechanisms, token management

Skill guide packs (MD + PDF), example topics:
- Auto Mechanic skill (demo)
- Family Doctor skill
- Auto‑improvement / how to make an agent learn from mistakes
GitHub repo with code and a wrapper that adds memory and preconfigured behaviors (links are noted in the video description / channel resources).
Community chat / group (“Operating System” community) for settings and discussion.

Video narrator / author: Operating System channel (the demonstrator, refers to himself as Alexey).
Agents (named personas used as roles):
- Heisenberg (main agent / orchestrator)
- Walter / Ulter (developer / performer)
- Saul / Sol (producer)
- Jesse Pinkman (marketer)
- Hank Schrader (security auditor)
- Skyler White (economist / accountant)
- Gustavo Fring (Obsidian / planning / Kaizen agent)
- Mike Ehrmantraut (backup / fixer agent)
Platforms/tools cited as sources: Claude, OpenClaw/Open Clow, Obsidian, GitHub.