The team is building genuinely sharp automations right now — Codex scripts, voice skills, a leader-brief HUD. That instinct is exactly right, and none of it is wrong. This page is about something quieter: the system already sending the daily pitches does everything those do — and keeps doing more — because of what it's built on.
It isn't one clever script. It's a fleet of agents sharing one memory, drawing on a relational graph, learning from feedback, and running on primitives that have outlasted every framework hype cycle. It does the read-your-email-and-summarize trick in its sleep. The interesting part is everything underneath.
A great one-off automation and a system can look identical in a demo. They are not the same machine — and the difference only shows up over time.
The daily pitch isn't "a script." It's the visible output of several specialized agents, each with its own local database, all coordinated by one orchestrator and all drawing on a single shared memory.
Here's the part that matters for cost: the shared memory means the data gets scraped once. Data Miner ingests a Slack thread; every other agent reads it from the shared store instead of re-pulling it. No agent re-scrapes what another already has. The fleet grows without multiplying the token bill.
The team's been building the right things with Codex. Here's what each one looks like when it sits on a fleet with shared memory instead of standing alone — not "instead of," but the same instinct with a higher ceiling.
When / Decision / Default / Risk / Checked — built static from one video transcript, with a private copy hand-redacted for sharing. A sharp frame, frozen to one snapshot.
The exact same decision-first columns are already a working demo — but fed from the shared DB, with source-confidence and provenance tracked per row, refreshed daily instead of frozen. See it →
Standing up a memory / infrastructure layer to give the agents something persistent to work from.
A persistent memory + relational graph has been running daily for months. The "custom roll" isn't a project to start — it's the substrate the whole fleet already runs on.
Score new ideas against the inferred hit-profile of top-performing articles and scripts.
The #content-ideas feed, the 400+ post archive, and the graph relationships are already ingested and connected. Hit-profile scoring runs on data that's already there — no fresh scrape, no cold start.
Loose scripts get written, then lost — marked done somewhere, but unfindable when you need them.
Every script, asset, and decision is cataloged in SQLite and the graph, queryable by name. The system checks what already exists before it builds anything new.
A written note on how to use the voice skills — valuable, but only if someone finds it and re-reads it.
The how-to lives as running skills + memory the system applies automatically on every run — not a document someone has to remember exists.
None of this replaces what the team is building. It's the same instincts — amplified by a substrate that remembers.
There's nothing exotic here and nothing to get locked into. The whole thing runs on technology older than most of the companies selling "AI infrastructure." Boring on purpose — boring is what survives.
Scheduled jobs. Runs the fleet on a clock. Half a century old and on every machine you'll ever touch.
A local relational database in a single file. No server, no vendor, no bill. It'll open in a decade exactly as it does today.
Skills, instructions, and artifacts as files on disk. Portable, diffable, backed up by copying a folder.
The relational layer over everything. Even this is a commodity primitive, not a proprietary platform.
No framework to get deprecated. No startup that can pivot and strand us. No migration when the next thing arrives. We're not reinventing the wheel every release — we keep the body and swap the brain.
The data layer is model-agnostic. The reasoning on top is a drop-in. So the same system inherits every frontier model the day it ships — no rebuild, no waiting on a vendor's roadmap.
Every release made it more capable, more efficient, and cheaper per run — with zero rebuild. The memory and the graph carry forward untouched; only the brain gets upgraded. A vendor product makes you wait for their roadmap. This one inherits the frontier the day it lands.
Anyone can copy the architecture in a weekend. Nobody can copy the months of enriched, cross-referenced data underneath it. That's the part that actually matters.
Snapshot as of May 28, 2026 — and denser by the time you read this. None of it is portable to whoever tries to copy the architecture.
People, projects, conversations, decisions, and sources — ingested from Slack, email, notes, and the content pipeline, then enriched and cross-referenced for months. Each node connected to others; each memory tagged, weighted, and recallable. A fresh "read-my-email" bot starts at zero today. This started at zero back on Opus 4.1, and it's gotten denser every single day since. The architecture is the cheap part. This is the asset.
Tap a stage. This loop runs every day, automatically, across the whole fleet.
The self-improvement loop runs on feedback — and it's been getting almost none.
The engine learns what's good by watching which pitches get picked, reacted to, built on. With weeks of silence, it's flying half-blind — still improving on its own internal signals, but missing the richest input there is: yours. The system has been underused, not because it's lacking, but because its best fuel hasn't been flowing.
React to the daily pitch. Reply "this one." Tell it what missed.
Every signal you give it gets folded back into the memory + graph and sharpens the next run. The compounding above accelerates the moment feedback starts flowing again.
Want to build one? Read the playbook →