Human approval at the center

Building with AI without handing over the wheel.

I run a practical multi-agent workflow for app building, review, operations, and release discipline. The models help move faster. The human still decides what ships.

Read the OpenClaw guide See the workflow

Operator stack

Two command lanes. One execution. One review.

System online

Command · Lane 01

Bixby / OpenClaw

Product Build Command

App architecture coordination, implementation routing, repo state, builds, QA orchestration, release gates, and blocker control.

What it does

Keep the active lane clear, the next move visible, and every specialist routed with purpose
Turn scattered project context into durable operating files, gates, and recovery paths
Protect approvals, memory, workflow state, and execution rhythm so the stack keeps moving without drift

Command · Lane 02

Atlas / Hermes

Operator Systems & Strategy

Strategy, research, specialist routing, content workflows, memory experiments, automation governance, and new revenue-oriented lanes.

What it does

Route strategy, research, and specialist work into clean execution lanes
Turn messy ideas into operator systems, content workflows, and revenue experiments
Pressure-test automation, memory, and governance before they become part of the stack

Core execution

Codex

Engineering Execution

Narrow-lane implementation, branch hygiene, tests, fixes, file rescue, and shipping support.

What it does

Turn narrow implementation tasks into clean, reviewable code changes
Protect branch hygiene, file state, tests, and recovery paths while work is moving
Ship focused fixes without dragging unrelated parts of the stack into motion

Strategy & review

Claude / Claude Code

Pressure Testing & Drafting

Architecture pressure tests, specs, review passes, drafting, language discipline, and checks before public or production-facing work.

What it does

Pressure-test architecture, specs, and decisions before they harden into shipped work
Turn rough thinking into clean specs, drafts, and language the rest of the stack can run on
Hold the line on scope, quality, and voice before anything goes public or production-facing

Human approval gate Required before ship. The system accelerates the work; the operator decides what goes out.

What this site is becoming

A field notebook for serious AI-assisted work.

This is not a generic prompt collection. It is a place for tested workflows: what broke, what fixed it, what I would do again, and what I would never repeat without a backup.

Build

App work with release discipline

Small lanes, clean branches, explicit QA gates, and human approval before anything important moves.

Operate

AI agents as a working system

Bixby/OpenClaw and Atlas/Hermes operate as the two command lanes. Codex handles narrow execution; Claude and Claude Code hold the review line before anything ships.

Public guides from real failures

If an update, build, or workflow goes sideways, the cleanup becomes a playbook someone else can use.

Recent breakpoints

The useful part is what failed and how it recovered.

This is the operator notebook lane: live scars, narrow fixes, rollback thinking, and the checks that keep an AI-assisted system from becoming a guessing machine.

Recovered

Telegram routing instability

ACP session binding looked alive while the working chat only showed task wrappers. The fix started with closing the stale lane, not rewriting the stack.

OpenClaw / Telegram / ACP

Guardrail

Approval flag mismatch

When automation wants to keep moving, the important question is not whether it can. It is whether the human approval boundary still holds.

Codex / human-in-loop

Watchlist

Playwright runtime resolution

Browser checks only count when the runtime, page state, and screenshot all agree. Otherwise the test lane is just noise with confidence.

QA / browser automation

Contained

Cloudflare deploy conflict

Deployment is the wrong place to discover missing artifacts. The save happens earlier: build proof, route proof, then ship.

Cloudflare / release checks

Field guides

Real AI workflow fixes, written down while they are still warm.

These guides come from live work: updates, broken routing, voice drift, release gates, and the recovery steps that kept the system moving without losing human control.

Hermes OpenClaw Codex Claude Code

How to safely update Hermes or OpenClaw with Codex or Claude Code

A practical operator playbook for updating agent infrastructure without panic: set guardrails, create a real backup, pause for GO, run the update, verify the gateway, smoke test Telegram, and only then return to live work.

Open the guide

Guardrails before commands The assistant gets a narrow lane: no deletes, no secret handling, no model changes, and no unrelated cleanup.

GO gate before update Version, gateway status, repo state, backup path, and checksum are reported before the update runs.

Verification after restart Gateway, Telegram, dashboard, Kanban, and an exact OK smoke test decide whether the maintenance window is done.

OpenClaw Codex Telegram Case study

How I upgraded OpenClaw with Codex without breaking my workflow

A practical guide for people who want a safer update lane: prepare the memory files, snapshot the config, update stable only, repair validation issues, and prove the agent is back before touching product work.

Open the guide

Stable first Update the known stable lane before experimenting with beta channels.

Backups before motion Config, auth, memory, workflow docs, and rollback instructions get preserved first.

Smoke tests after restart Gateway, Telegram, Codex auth, Drive path, and normal reply behavior all get checked.

OpenClaw Persona drift Voice canon Bixby

How I fixed OpenClaw agent persona drift without breaking the workflow

A practical guide for restoring an agent's real operating voice: audit conflicting memory, build a voice canon, separate human mode from command-center mode, regression-test the behavior, and checkpoint before touching model config.

Open the guide

Prompts were not enough The issue lived in persistent memory and load order, not just one bad reply.

Examples beat adjectives Concrete before/after replies taught the agent where the voice boundary actually lives.

Model changes stayed parked Persona repair and runtime model cleanup were separated so one fix could be judged at a time.

Hermes Agent Honcho Memory Atlas

How I added Honcho memory to Hermes Agent

A practical operator guide for adding a conservative long-term memory layer to a Telegram-connected Hermes agent: tools-only recall, per-session starts, cadence control, verification, and rollback without changing the agent's voice.

Open the guide

Built-in memory stays active Honcho is added as an external provider, not a replacement for the Hermes baseline.

Tools-only first Atlas can use Honcho when useful without automatic context flooding every reply.

Cadence gets verified The setup is not trusted until status shows the expected every-5-turn memory cadence.

Hermes Agent Sub-agents Atlas Approval gates

How I built a bounded Hermes sub-agent system

A practical guide for creating specialist Hermes agents without turning them loose: role docs, profile shells, runtime packages, launcher routing, tool boundaries, QA audits, and human approval before automation.

Open the guide

Specialists stay bounded Research, QA, build planning, documentation, and automation review each get their own lane.

Launchers enforce shape Profiles are routed with explicit toolsets, skills, source paths, and output folders.

Approval comes first OAuth, publishing, scheduling, and external action stay blocked until they are separately approved.

Operating principle

Use the models like a team, not a slot machine.

The goal is not to make AI look magical. The goal is to turn messy, real work into repeatable lanes: plan, inspect, isolate, verify, document, and only then ship.

Separate lanes

Implementation, review, operations, and product decisions stay distinct so one confused thread does not contaminate the whole project.

Preserve state

Memory files, checklists, and branch snapshots turn long work into something recoverable when a session resets.

Verify the boring parts

The boring checks are where the save happens: config validates, tests pass, build artifacts exist, and chat routing behaves.