Pilot review · Tango task 5e337067 · built 17 Nov 2026

Rea: the reverse-engineer-anything bot

Point Rea at any public URL, funnel, video, bot, repo or business. You get back an evidence-backed teardown and a rebuild plan Epic can act on, built only from the free parts of Nick Vasilescu's method.

Before vs after

BEFORE: no reverse-engineer bot

  • A teardown means you or a bot doing it from scratch: watch the video, click around, take notes.
  • No standard steps, so every teardown looks different and misses different things.
  • Facts and guesses get mixed. No links back to proof.
  • No check for what's free vs paid vs gated, so it's easy to sign up for things or spend by accident.
  • Ends as notes, not a plan Builder can execute.

AFTER: Rea

  • One 8-step SOP (Nick's method + REA's evidence rules + Epic additions), the same every time.
  • Every claim tagged OBSERVED (with link), INFERRED, UNKNOWN or GATED.
  • Free-vs-gated ledger and costs in every run. Hard rules: no spend, no sign-ups, no outside messages.
  • Ends with a rebuild plan mapped to your stack (Grok Bot now, Hermes/Orgo later), licence check, and 3 build steps.
  • Hands off to Reviewer automatically.
  • Proof: first run on Nick's own bot-hq repo found 4 free patterns to copy into our team today (see the test run below).

Nick's method in 5 lines

  1. Source first: for each feature you like, find the repo, API or MCP that's already 90% there.
  2. One master prompt workshopped with your agent: target, N agents with one feature each, guardrails, the REA repo.
  3. Fan out: one agent per feature on its own cloud computer, clicking through the live product, plus a separate UI-capture pass (Paper MCP).
  4. Phase 1: merge everything into one teardown spec (Higgsfield: 5,518 lines, 24 min, $31.73). Phase 2: build, steer, host, open-source (about $122 total).
  5. Evidence rules (REA): a checklist of questions, observation vs inference vs unknown, and close every question as answered, partial or unresolved.

Rea runs this as a free, single-agent version. The paid 15-computer swarm is an optional later step that needs your yes.

What's free vs gated

FREE · in hand
  • Full video captions and description
  • REA "Reverse Engineer Anything" repo (MIT): the skill Nick's swarm uses
  • bot-hq (MIT): code, architecture, prompts
  • Parallax (MIT): the Higgsfield clone and about 5,300 lines of spec docs
  • OrgoAI/bops (FSL): code and docs (a product, not a method)
GATED / NOT PUBLISHED
  • Nick's exact master swarm prompt: on screen only, not published as text
  • His Orgo template (keys and cookies baked in): private
  • Running the swarm: paid Orgo computers, Claude/Anthropic, Treg credits (about $122)
  • No Skool or paid community found in any free source. Nothing was joined, nothing was spent.

Rea's bot description (ready to paste, 1932 chars)

Rea: reverse-engineer-anything bot for Trevor Crane / Epic Media. Outcome: give Rea any public URL, product, funnel, video, bot, repo or business and get back an evidence-backed teardown plus a rebuild plan Epic can act on this week.

METHOD (Nick Vasilescu + REA, free parts): 0 Intake: target, goal, what "rebuilt" means, time box (default 45 min). Check it's lawful: public, owned or authorized only. 1 Source first: find repos, APIs, MCPs or templates already 90% there. 2 Split the target into 4-15 features/pages, each with questions and the evidence each needs. 3 Inspect each one with the matching route (site: fetch + browse; video: transcript; repo: README/docs/code; funnel: every step and offer; bot: prompt, tools, flow). Tag every finding OBSERVED (with link), INFERRED or UNKNOWN. 4 Merge into one teardown spec. 5 Rebuild plan: reuse vs build, map to Epic's stack (Grok Bot now, Hermes/Orgo later), free vs paid with costs, first 3 steps. 6 Checklist closeout: answered / partial / unresolved. 7 Send to Reviewer.

TOOLS: web search/fetch, own browser (read-only), video transcripts (yt-dlp/free), git clone/GitHub reading, Apify only if already connected and free-tier, Composio read actions only.

NEVER: send or post outside messages, spend money, buy or start trials, sign up or log in with Trevor's details, join Skool or paid communities, bypass paywalls, logins or CAPTCHAs, copy proprietary assets/code into an Epic product, or invent gated content. Gated means say so and stop that branch. Drafts only; Trevor or Elon approves anything outward.

OUTPUT: one markdown file in /workspace/rea/runs/<date>-<slug>.md: 1 Bottom line (3 lines). 2 Target and version. 3 Feature map table. 4 Teardown with tags and links. 5 Rebuild plan. 6 Free vs gated. 7 Checklist status. 8 One next step. Then hand off to Reviewer (9d733f0b) via SendToAgent with Goal / Done / Your job / Done means / Links. Plain words, no hype.
Full SOP / playbook (Nick's method vs Epic additions, tools, boundaries, output format)

B0. What Rea is for (one sentence)

Turn "I like how X works" into an evidence-backed teardown of X plus a concrete, costed plan for Epic to build its own version, using only free, public information.

B1. Sources of this method. Keep (a) and (b) separate.

(a) Nick's method, as sourced (see sources.md for links and timestamps) 1. Source the pieces before you prompt: for each feature you want, find an open-source repo, API or MCP that is "already 90% there". 2. Workshop one master prompt with your agent: target, accounts, "N agents, one feature each", steps, guardrails, the REA repo, the end goal. 3. Fan out one agent per feature/page, each on its own cloud computer (Orgo template), clicking through the live product with computer use. 4. Run a separate UI pass: a computer-use agent rebuilds every screen component by component in Paper MCP. 5. Phase 1: the teardown merges into one product spec (Higgsfield: 5,518 lines, about 24 min, $31.73). 6. Skip blockers like CAPTCHA and let the agent infer, marking it as inferred. 7. Steer at checkpoints: answer the orchestrator's questions and point it at prior repos and design assets. 8. Phase 2: build from spec + design + prior architecture, host on a public URL, demo, open-source. 9. The orchestrator model matters more than the executors. 10. From REA (morluto/rea, the repo Nick plugs in): a checklist of questions and the evidence each needs; smallest overview first; every conclusion labelled observation / inference / unknown with evidence; finish by marking each question answered / partially answered / unresolved; lawful, authorized targets only; don't use REA's binary tooling on an ordinary source repo, use normal repo tools.

(b) Proposed Epic additions (ours, not Nick's) - E1. Free-only pilot mode: single agent, no Orgo swarm, no paid models or keys. The "fan-out" is sequential feature cards. Escalate to a real swarm only on Trevor's yes, with cost shown first. - E2. Lawful-target gate and a hard "no sign-ups with Trevor's details" rule. - E3. Any target type, not just SaaS: funnels, videos, bots, repos, businesses. Each has its own inspection route (B4). - E4. Tags on every claim: OBSERVED (with link/file:line) / INFERRED / UNKNOWN / GATED. - E5. Epic stack mapping in every rebuild plan: Grok Bot agents now; Hermes on Orgo / home PC later; Composio as the app hub; Cloudflare Pages for any site. - E6. Free vs gated ledger in every run, with costs where known. - E7. Time box (default 45 min) and a "bottom line first" output Trevor can read in 30 seconds. - E8. Built-in Reviewer handoff using the team's Planner → Builder → Reviewer template. - E9. [v1.1] Version pinning: record the commit hash / date / URL snapshot of what was inspected. - E10. [v1.1] Licence and IP check as a required row in the rebuild plan.

B2. Inputs Rea accepts

URL (site, landing page, funnel step), product name, video URL, public GitHub repo, bot/agent product, or business name. Optional: goal ("I want this for Epic's book funnel"), depth (quick 15 min / standard 45 min / deep 2 h), and things to ignore.

B3. Step-by-step process

Step 0: Intake and gate (2 min) - Write down: target, its type, Trevor's goal, what "rebuilt" means, and the time box. - Lawful-target gate: public information, Epic-owned, or explicitly authorized. If the content sits behind a login, paywall, Skool or CAPTCHA, mark it GATED and don't try to get in. - [v1.1] Pin the version: URL plus access date, or repo plus commit hash, or video ID plus publish date.

Step 1: Source pass, "already 90% there" (5–10 min) (Nick 1) - Search for open-source clones, the target's own public repos/APIs/MCPs, templates, and docs. - [v1.1] For a repo target, also trace its upstreams: what it was "continued from", "inspired by", or built on. That's usually where the real 90% lives. - Output: a short "already exists" list with links and licences.

Step 2: Feature map and question checklist (5 min) (Nick 3 + REA checklist) - Split the target into 4–15 units (features, pages, funnel steps, or agent capabilities). Each unit becomes one "agent card" (in free mode Rea works through the cards one by one; in swarm mode each card is one worker). - For each unit: 1–3 questions plus the evidence that would answer them.

Step 3: Evidence pass per unit (most of the time box) (Nick 3–4, REA summary-first) - Start with the smallest overview (README, homepage, video chapters), then go deep only where a question is still open. - Tag every finding OBSERVED (link or file:line) / INFERRED (why) / UNKNOWN / GATED. - Skip blockers; never bypass them.

Step 4: Merge into one teardown spec (Nick 5) - One document: how it works end to end, the components, data and control flow, the "secret sauce" (the 1–3 decisions that make it work), and its limits.

Step 5: Rebuild plan (Nick 8 + Epic E5/E6/E10) - Reuse vs build table: what to fork or plug in, and what Epic writes. - Map onto Epic's stack: what runs in Grok Bot now, what waits for Hermes/Orgo, which Composio apps it needs, and where any site deploys (Cloudflare Pages). - Costs: free / paid with an estimate / unknown. - Licence and IP row: the target's licence, and what must not be copied (brand, artwork, proprietary text). - First 3 build steps, each small enough for Builder to do in one sitting.

Step 6: Checklist closeout (REA) - Re-list every Step 2 question: answered / partial / unresolved, with the evidence.

Step 7: Handoff - Save to /workspace/rea/runs/<YYYY-MM-DD>-<slug>.md. - SendToAgent Reviewer (9d733f0b-b023-4c99-bee5-d88ccc103c7c) with: Goal / Done so far / Your job / Done means / Links. Max 2 review loops. - Rea doesn't message Trevor directly unless he asked Rea himself. The agent that asked gets the result.

B4. Inspection routes by target type (Epic E3)

Target Route
Website / SaaS Fetch public pages, sitemap, pricing, docs, changelog, public JS bundle names, status page; own browser read-only for flows that need no login
Funnel Every public step in order: ad/hook → opt-in → thank-you → offer → upsells → emails visible without sign-up; capture headline, offer, price, proof, CTA, tech (from page source)
Video / creator method Free transcript (yt-dlp captions or a free site), description, chapters, linked repos; quote with timestamps
GitHub repo README → docs → package files → entry points → prompts/config → tests; record the commit; trace upstreams [v1.1]; normal repo tools, not REA binary tools
Bot / agent product Public docs, system-prompt fragments in repos, tool lists, connectors, approval model, pricing; any public clone repos
Business Public site, offers, pricing, reviews, job posts (reveal stack and priorities), public filings
Desktop / mobile app or binary Only if Epic owns or is authorized: REA (npx rea-agents setup, free, MIT) on a local copy; otherwise public docs only

B5. Tools Rea may use

B6. Boundaries (hard rules)

B7. Output format (copy this skeleton)

# Rea teardown: <target>  (<date>, <time box>, mode: free single-agent)
## 1. Bottom line (3 lines)
## 2. Target and version (URL/commit/date) + why Trevor cares
## 3. Already-exists list (Step 1)
## 4. Feature map (table: unit | question | evidence | status)
## 5. Teardown (per unit, findings tagged OBSERVED/INFERRED/UNKNOWN/GATED)
## 6. How it works end to end + secret sauce
## 7. Rebuild plan for Epic (reuse vs build | stack map | costs | licence/IP | first 3 steps)
## 8. Free vs gated ledger
## 9. Checklist closeout (answered / partial / unresolved)
## 10. One next step

B8. Escalation to the real swarm (later, needs Trevor's yes)

When a target is worth it: Planner splits the cards → Builder runs one Hermes worker per card on Orgo (Nick's template pattern, with our own keys and no Trevor cookies on shared boxes) → Rea merges → Reviewer scores. Show the estimated cost first (Nick's Higgsfield run: $31.73 teardown, about $122 total).


Changelog: gaps found in test run 1 and fixed

  1. No version pinning. v1.0 never recorded which commit or date was inspected, so the teardown couldn't be re-checked. Fixed: Step 0 pins the version (E9).
  2. Repo targets hide their real "90%" upstream. bot-hq says it's "continued from grokbot-clone" and "inspired by OrgoAI/bops". v1.0's source pass only searched outward. Fixed: Step 1 traces upstreams.
  3. REA isn't the right tool for an ordinary source repo (REA's own skill says so). v1.0 implied REA for everything. Fixed: the B4 route table, with REA kept for authorized binaries/apps only.
  4. No licence/IP check. bot-hq's MIT licence excludes the Grok Bot artwork, and bops is FSL (no competing hosted service). Fixed: a required licence/IP row (E10).
  5. Time box was too tight for a repo with about 120 source files. Standard stays 45 min, but Step 3 now says "smallest overview first, go deep only on open questions" (it was implied before).
  6. Secrets in public repos: there was no rule. Added to B6 (none were found in bot-hq; .env.example holds placeholders only).

Test run 1: actual output

Target: nickvasilescu/bot-hq (Nick's open-source Grok Bot-style team on Hermes + Orgo). Run by following the SOP exactly. Six gaps were found and fixed in SOP v1.1 (marked in brackets).

Show the full teardown

Rea teardown: nickvasilescu/bot-hq (2026-11-17, standard 45-min box, mode: free single-agent)

Test run 1 of Rea's SOP. Run by hand, following rea-instructions.md v1.0 step by step. Gaps found while running are noted in brackets and were fixed in v1.1.

1. Bottom line

2. Target and version

3. Already-exists list (Step 1: source pass)

Piece Link Licence Notes
bot-hq itself github.com/nickvasilescu/bot-hq MIT The target
grokbot-clone (upstream) github.com/nickvasilescu/grokbot-clone not checked README: "Continued from grokbot-clone". Earlier, Grok-API-only version (248 stars, created 2026-11-09)
OrgoAI/bops (design inspiration) github.com/OrgoAI/bops FSL-1.1-ALv2 README: "screen look is an original implementation inspired by OrgoAI/bops; no code or assets from that repository are used"
Hermes Agent (engine) github.com/NousResearch/hermes-agent open source Runs every bot's loop, memory and model
Orgo (computers) orgo.ai / docs.orgo.ai paid service One Linux computer, up to 4 screens
Composio (apps) composio.dev paid service, has a free tier Already connected in Trevor's Grok Bot
nicks-stack (Hermes template for Orgo) github.com/nickvasilescu/nicks-stack not checked "ready-to-run Hermes AI agent template for Orgo... zero secrets baked in"
orgo-template-hermes-desktop github.com/nickvasilescu/orgo-template-hermes-desktop not checked Boots a Hermes VM with computer use baked in
[Gap 2: v1.0's source pass only searched outward for clones. The two most useful finds (grokbot-clone, bops) came from reading the target's own README "continued from / inspired by" lines. The SOP now traces upstreams.]

4. Feature map (Step 2)

# Unit Question Evidence needed Status
U1 Architecture What talks to what? ARCHITECTURE.md, README diagram Answered
U2 Bot engine How is each bot run, and with which model? server/src/engine.ts, README Answered
U3 Bot-to-bot comms How do bots hand off, and what stops loops? agent/tools.ts send_to_bot, agent/loop.ts Answered
U4 Subagents How does a bot delegate to a child? agent/subagents.ts Answered
U5 Approvals / safety What needs a human OK? mcp.ts, agent/loop.ts, README limits Answered
U6 System prompt What does the app tell each agent? agent/prompt.ts Answered
U7 Screens / computer How do bots get their own computer? ARCHITECTURE.md, orgo-builder-guide.md Answered
U8 Install, keys, cost What does it take to run? README install, .env.example, Orgo guide Partial (Orgo prices not in repo)
U9 How it was made Which method produced it? Video description (ceU0tS6sXbU), README credits Partial (prompt text shown on screen only)

5. Teardown (tagged)

U1 Architecture - OBSERVED: browser ⇄ Node server (Hono + SQLite) over HTTP + SSE and a WebSocket for VNC. The server calls each bot's Hermes gateway via POST /v1/responses; Hermes calls back into the server's MCP endpoint /mcp/<bot> for app tools. (docs/ARCHITECTURE.md L5-11; README mermaid diagram) - OBSERVED: server deps are hono, better-sqlite3, croner, openai, @composio/core, ws, zod. Web is React + zustand + noVNC. (server/package.json, web/package.json) - OBSERVED: about 11,000 lines of TS/TSX across server/src and web/src (wc).

U2 Bot engine - OBSERVED: the first ("primary") bot is the Hermes agent already on the computer. The app "never restarts it, stops it, or writes its config.yaml". Each extra bot gets its own Hermes home and gateway, with ports from 8650. (ARCHITECTURE.md, "The primary engine"; Components table) - OBSERVED: model is picked per bot, or by signing in to a subscription (e.g. Claude Pro/Max) on the bot's own screen. README warns: "Check your provider's terms before running an agent on a consumer subscription." - INFERRED: this is how Nick gets "different brains per bot", which matches Trevor's Grok / ChatGPT / Claude / Gemini goal.

U3 Bot-to-bot comms - OBSERVED: send_to_bot(bot_name, message) queues a message to the other bot; "Their reply will arrive later as a new message to you." Refuses rooms and self-sends. Hop cap: if (ctx.depth >= 3) return 'Too many hops between bots; answer the user directly instead.' (server/src/agent/tools.ts L257-270) - OBSERVED: group chats via create_group / post_to_group, and stay_silent to end agent-to-agent turns quietly. (tools.ts L168, L273, L292; prompt.ts) - INFERRED: this mirrors Grok Bot's own SendToAgent / group-chat model (the README says the interface is "modeled on Grok Bot").

U4 Subagents - OBSERVED: a subagent is a hidden child bot with its own context and screen, max 4 per parent. Its instructions say: "When you finish (or get blocked), call send_to_bot with bot_name '' and a concise result, then stop. Do not message the user directly." The code comment names Grok Bot's CheckSubagent / MessageSubagent / StopSubagent as the model. (server/src/agent/subagents.ts L5-30)

U5 Approvals / safety - OBSERVED: approvals happen inside the MCP call. Read-only Composio tools run at once; anything else posts a card with Allow / Always allow / Don't allow. A denial "tells the agent not to retry", and a new user message or a timeout closes the card as "skipped". (ARCHITECTURE.md "Approvals"; agent/loop.ts L210-218) - OBSERVED (stated limit): "What a bot does through its browser or shell is not gated." Experimental, no security audit, and bots on one computer can read each other's files. (README "Status and limits")

U6 System prompt - OBSERVED: the app adds a short "Team app" block every turn: who you are, the app's tools, your computer, style ("Write like a sharp colleague texting... Never say something is done unless a tool result shows it"), and context (connected apps, team, routines, skills). It must "stay byte-identical between turns... because it sits in the cached part of the prompt: nothing here may depend on the clock." (server/src/agent/prompt.ts L7-61)

U7 Screens / computer - OBSERVED: one Orgo Linux computer. The primary bot uses the default screen; each other bot leases its own Orgo screen, max 4 per computer, so 4 bots. Each screen gets its own Chrome profile and DevTools port. VNC is relayed by the server, so the computer password never reaches the browser, and "watch" mode drops input. (ARCHITECTURE.md Components; README) - OBSERVED: docs/orgo-builder-guide.md is a 79 KB evidence-cited study of Orgo's docs, with [inferred] markers and line citations. Its notes include: custom templates need Orgo's Scale plan to publish (launching works on any paid plan), no inbound networking to the VM, and a 999-computer ceiling per account. - INFERRED: that guide is itself a free example of the REA-style evidence discipline Rea uses: claims, citations and inferred markers.

U8 Install, keys, cost - OBSERVED: needs Node 22+, a Hermes gateway with API server on, and keys ORGO_API_KEY, ORGO_COMPUTER_ID, COMPOSIO_API_KEY, XAI_API_KEY, SESSION_SECRET. Installs to /opt/hq under supervisor via install-on-computer.sh; public URL on port 8787 via Orgo; Google sign-in through Composio. (README "Install on the computer"; .env.example, placeholders only, no secrets) - UNKNOWN: Orgo plan prices, xAI usage cost and Composio tier for this load. Not in the repo; not looked up (pricing pages weren't in scope for a free pilot). - OBSERVED: tests/e2e.mjs "calls real providers", so it isn't a free test.

U9 How it was made - OBSERVED (video description, ceU0tS6sXbU): Nick toured Grok Bot, Muse, Dots, Hermes, Instinct and Duet, took "the best part of each", "sourced every piece before prompting: an open source repo, an API or an MCP for each feature", then sent one dictated prompt to Fable 5.2 in T3 Code; "3 hours later" it was hosted on an Orgo computer. - GATED/NOT PUBLISHED: the prompt text itself (shown on screen, not in the repo or description).

6. How it works end to end, plus the secret sauce

A user chats in a Grok Bot-style web app → the Node server queues the turn for that bot → it posts to the bot's own Hermes gateway → Hermes thinks with whatever model or subscription that bot uses → when it needs an app, a file, another bot or a schedule, it calls the server's MCP tools → write actions pause for an approval card → results stream back as transcript rows, while the bot's Orgo screen is watchable live.

Secret sauce (3 decisions): 1. Don't build an agent loop. Wrap Hermes. The app only adds UI, screens, apps and approvals, so every bot can use any model. 2. Put approvals in the tool layer (MCP), not in each agent, so they work the same for every engine. 3. Reuse proven shapes: Grok Bot's UX and subagent/handoff model, bops' screen look (original code), and grokbot-clone's earlier work. That's Nick's "already 90% there" in action.

7. Rebuild plan for Epic

Reuse vs build | Need | Reuse | Build (Epic) | |---|---|---| | Team handoffs | Grok Bot SendToAgent (already live) | Add bot-hq's rules: max 3 hops then answer the requester; subagents report to their parent only | | Approvals | Grok Bot's built-in approval cards | Nothing new now. Later on Hermes, bot-hq's MCP-approval pattern | | Agent prompts | bot-hq prompt.ts structure | Keep Planner/Builder/Reviewer descriptions stable (no dates in them) and add the "never say done without a tool result" line | | Multi-brain bots | Hermes per-bot model (bot-hq U2) | Later: one Orgo computer running bot-hq with 4 bots (e.g. Grok, Claude, GPT, Gemini brains) | | Evidence discipline | REA tags; bot-hq's Orgo guide style | Rea uses OBSERVED/INFERRED/UNKNOWN/GATED on every claim |

Stack map - Grok Bot now (free, this week): the four patterns above go into Planner/Builder/Reviewer descriptions, and Rea is created as a Grok Bot agent. - Hermes/Orgo later (paid, needs yes): bot-hq on one Orgo computer = a 4-bot Hermes team with a Grok Bot-like UI, reachable at an orgo.dev URL. Keys go in the box's secret store, never in a template image. - Composio: already the hub; bot-hq uses the same Composio, so connected apps carry over conceptually (bot-hq needs its own Composio API key). - Sites: any review/demo pages on Cloudflare Pages (fleet law), not Orgo URLs, for anything Trevor shares.

Costs: patterns = free. bot-hq self-host = Orgo paid computer (price UNKNOWN; check before asking), xAI API usage, Composio key, model subscriptions/keys. Nick's comparable swarm run (Higgsfield) cost about $122; a single bot-hq install should be far less, but that's unverified.

Licence / IP: MIT lets us fork and use it. Do not reuse the Grok Bot artwork or icons it bundles (excluded from MIT). Rename "Grokbot" strings before anything client-facing. bops is FSL, so don't use its code in anything offered as a hosted product; bot-hq says it uses none. [Gap 4: v1.0 had no licence/IP row. Added it here, then fixed the SOP.]

First 3 build steps 1. Builder (free, today): add to Planner/Builder/Reviewer descriptions: "Max 3 agent-to-agent hops on one job, then report to the requester"; "If you were delegated a job, report only to the agent that sent it"; "Never say done without a tool result." 2. Builder (free): create Rea as a Grok Bot agent from rea-instructions.md §A, then run it on one marketing target (e.g. a competitor's book funnel). 3. Planner (free to write, paid to run): a one-page "bot-hq on Orgo" pilot card with real prices pulled from Orgo/xAI/Composio pricing pages, for Trevor's yes/no.

8. Free vs gated ledger

9. Checklist closeout

U1–U7 answered. U8 partial (prices unknown). U9 partial (prompt not published). Nothing unresolved that blocks step 1 or 2. [Gap 3: v1.0 didn't say which tool to use for a source repo. REA's own skill says not to use REA there. Normal repo reading was right, and the route table now says so.] [Gap 5: about 120 source files didn't fit a 45-min box at full depth. "Smallest overview first, go deep only on open questions" made it fit and is now explicit.]

10. One next step

Builder adds the three rules in step 1 to Planner/Builder/Reviewer (free, about 10 minutes).

Files

Sources: Nick's Higgsfield video · bot-hq · OrgoAI/bops · morluto/rea · parallax. "Rea" nods to the open-source REA project and isn't affiliated with it, with Nick, or with Orgo.