Implementations

The patterns in this wiki are general-purpose. Memory, model coordination, guardrails, and scheduling work the same way whether the agent manages a portfolio, runs a content pipeline, or monitors infrastructure. Below are real implementations that use these primitives in different domains.

Master Rulebook — Automated Trading

The system that drove this wiki into existence. Four automated strategies run on a Mac Studio with Claude Code as the orchestrator. 40+ cron jobs handle screening, monitoring, position tracking, and reporting throughout the day.

The harness handles memory across sessions, routes research to Grok and code tasks to Codex, blocks writes to live execution scripts via the audit hook, and generates a daily dashboard with AI-powered triage of health check results.

This implementation pushed every pattern described in this wiki to its limits. The security guardrails exist because an agent modified a production file. The memory system exists because re-explaining context every session was wasting hours. The model coordination exists because no single model does everything well.

Master Rulebook Wiki covers the trading strategies, backtest results, and execution rules. This wiki covers the machine underneath.

Open Brain — Personal Knowledge Base

Nate B. Jones' Open Brain project connects a Supabase Postgres database to AI tools through an MCP server. The agent reads and writes thoughts, schedules, contacts, and notes through standardized MCP calls. Any AI tool that supports MCP (Claude, ChatGPT, Cursor) can access the same memory.

The core idea maps directly to the Memory and Continuity patterns in this wiki. Open Brain uses SQL where we use markdown files. Both achieve the same goal: the agent remembers what happened yesterday without the operator re-explaining it.

Community implementations include household knowledge bases, family calendars, CRM systems, and daily digest generators. Setup takes about 45 minutes.

Source: github.com/NateBJones-Projects/OB1

Personal AI Infrastructure — Daniel Miessler

Daniel Miessler's PAI layers tiered memory, TELOS goal files, hooks, and 63 skills on top of Claude Code. The system uses memory tiers (short-term session context, medium-term project state, long-term identity and preferences) and modular skill packs for reusable behaviors.

His approach to feedback capture matches what we describe in the Memory section: corrections accumulate over time so the agent improves without repeating mistakes. The TELOS framework adds explicit goal tracking that sits above individual sessions.

Source: github.com/danielmiessler/Personal_AI_Infrastructure

OpenClaw Community Patterns

OpenClaw is the open-source agent framework that made autonomous AI agents mainstream. The community has built thousands of skills and configurations around its core primitives: a Gateway daemon for scheduling, SOUL.md for identity, AGENTS.md for behavior rules, and session-based multi-agent coordination.

Several patterns from the OpenClaw ecosystem map to this wiki:

Overnight coding loops. An agent receives a goal (improve test coverage, refactor a module, migrate a dependency), works through the night, and delivers results by morning. The loop uses file-based state to track what was tried, what worked, and what to try next. This is the Scheduling pattern combined with Memory.

CRM and sales pipelines. Agents run morning scans against a customer database, identify at-risk accounts by comparing current metrics to historical patterns, and draft outreach. This combines Memory (account history), Tools (CRM API), and Scheduling (daily runs).

Content calendar management. Agents check publishing schedules, cross-reference upcoming posts with recent news, flag conflicts or opportunities, and suggest updates. This is Scheduling plus Memory plus web research Tools.

Job search automation. Agents scan postings on a schedule, compare requirements against a stored resume, update cover letters with recent project details from memory, and queue applications for review.

Each of these follows the same cycle: wake up on schedule, read memory, call tools, take action, write results back to memory. The domain changes. The architecture does not.

What These Have in Common

Every implementation above uses the same building blocks:

Persistent state that survives session boundaries. Whether it lives in SQL, markdown files, or a vector store, the agent needs to read what happened before and write what happened now.

Scheduled execution that runs without the operator pushing a button. Cron jobs, Gateway daemons, or Claude Code's /loop command. The mechanism varies. The requirement does not.

Tool access that lets the agent change things in the real world. APIs, file writes, message sends, database updates. Without tools, the agent is a brain without hands.

Guardrails that prevent the agent from doing damage when it runs unsupervised. Audit trails, protected paths, content sanitization, alert systems. The more autonomous the agent, the more these matter.

The rest of this wiki explains how to build each of these pieces. The implementations above show what happens when you put them together.