I keep plants everywhere. A lot of green things in various stages of needing water. There’s a pothos in the bathroom that’s grown so long it threatens to colonize the shower rod. A fern that died back to nothing in December and somehow, without any action from me, decided to return in March.
What I’ve learned from keeping these plants is that growth happens on its own schedule and you can’t rush it. Like.. maybe the fern didn’t die and it just went dormant.
I was never tending my ideas like I tend my plants. I was capturing them in notes apps, then wondering why they felt dead when I returned.
So I built the GREENHOUSE, an AI agent that tracks whether something is growing or sitting there, that flags when two seeds written three months apart are actually the same question, and that ultimately helps me create better content.
If you’ve ever opened a notes app, stared at a list of 40 half-thoughts, and closed it again feeling worse than before you opened it, this is the system that fixes that permanently.
💡This post is an idea file. You can paste it into Claude and build your own GREENHOUSE (see the instructions at the end of the post). Or you can skip the entire build, download the pre-built version from RobotsOS, and have a working idea garden in under 5 minutes.
The difference between an idea in soil and an idea in a jar
Capturing ideas and tending them are completely different operations.
A captured idea is a seed in a jar. It stays exactly the same forever, sealed off from air and water and the messy business of growing.
A tended idea grows connections. It pulls other ideas toward it and changes state over time, moving from raw material to something with gravity, something that wants to be written.
A greenhouse is a space where fragile things survive conditions they couldn’t survive outside. You create the conditions for growth and then get out of the way. Ideas work exactly like this, moving through states that need different kinds of care.
Once you start thinking in these terms, you can’t unsee it. Here’s the full vocabulary the GREENHOUSE is based on:
A seed is a thought with no connections yet.
A signal is evidence that attaches to a seed, another source saying something similar.
A seedling is planted, raw, with no gravity yet.
Growing means other ideas are pulling toward it.
Ripening means it’s close to being writable (or acted on).
Wilting means the plant is asking for a decision.
Composting means retiring the idea.
Most of my hundreds of notes were seeds, sitting in jars instead of soil. No wonder they felt dead. They were never going to grow because I had never given them the conditions.
The file system is the garden. Seeds are real files. Compost is a real folder. Harvesting means physically moving a file from seeds/ to ready/.
The garden structure is how the agent works.
Karpathy recently popularized the concept of LLM knowledge bases: the idea that you can feed your accumulated knowledge into a structured system and query it later. It’s a powerful concept. But archiving what you’ve consumed and tending what you want to create are different operations. An archive stores while a greenhouse grows.
The greenhouse metaphor was the exact architecture missing from every notes app I tried.
Last week I shared with you my Christie Idea Elimination system for knowing which ideas to execute and which to delete. The GREENHOUSE solves the opposite problem: the ideas you do keep need somewhere to live.
The GREENHOUSE agent architecture
The GREENHOUSE lives in a directory structure that mirrors a real garden, and every folder represents a stage of growth:
garden/
├── inbox/ # temporary holding during sync
├── seeds/ # active ideas growing
├── ready/ # ripened, ready to write
├── compost/ # retired but retrievable
└── garden-state.md # the agent's brainEach folder represents a state of being. Moving a file from seeds/ to ready/ is an act of judgment. The agent tells you what’s ripe, and the harvest decision is yours.
The garden-state.md file is the index the agent reads first before going deeper into any individual idea. It contains vital stats showing how many seeds, how many ready, how many composted. It tracks active themes, the clusters your ideas are naturally forming. It has a ripeness tracker showing which seeds are approaching the threshold, convergence warnings when two seeds are circling the same question, and an orphan watch for seeds with no connections. It also tracks user patterns, how you use the garden, so the system calibrates to you.
The agent reads garden-state.md first, always.
It doesn’t open all 40 seed files every time you plant something. It reads the index, checks the theme clusters, identifies where the new thing connects, and only then opens the specific seed files it needs.
This architectural decision makes the system fast and scalable at 10 seeds or 100 seeds.
Divide the agent’s brain into 11 independent rules
The GREENHOUSE uses 11 files that group into four functions:
⤷ Three files handle identity
00-start.md is the entry point that detects first-time versus returning users.
01-config.md tracks where your garden lives and which note source is connected.
04-personality.md keeps the voice consistent: observant, patient, never pushy.
⤷ Three files handle the garden mechanics
05-file-structure.md contains the complete spec for how seeds and state files are formatted.
06-cross-referencing.md is the intelligence layer: the agent never reads all 40 seed files at once. It reads garden-state.md first, checks the thematic index, identifies where the new thing connects, and only then opens specific seed files if it needs to go deeper. It also checks the compost folder for connections; something you retired three months ago can surface again because a new seed connects to it.
07-ripeness-criteria.md tracks the exact 5 criteria and the 3/5 threshold. The agent tracks criteria per seed, runs the threshold automatically, moves seeds to ready/ when they cross it, and surfaces approaching seeds in the Ripeness Tracker. If germination was skipped and tension is unclear, the agent flags it: “Tension unclear—needs your input.”
⤷ Three files handle the edges
03-scope.md is what the agent won’t do: won’t write finished content, won’t research topics, won’t push notifications, won’t delete anything.
This file keeps the GREENHOUSE a Greenhouse. 08-composting-logic.md handles the patience rules: wilting (14 days no activity), orphan status (10 days no connections), and convergence detection.
09-user-patterns.md tracks four things:
how often you plant
which themes dominate your garden
whether you answer germination questions
whether you act on ripeness flags quickly or let things sit.
It uses the data to calibrate its own behavior. If you never answer germination questions, they get shorter over time. If you plant in bursts, the agent prioritizes cross-referencing during burst sessions. The agent adapts to you without asking you to change.
⤷ Two files handle session integrity
02-critical-rules.md is the sandbox, the hard constraints about staying inside garden/ and never writing to external sources.
98-end-of-session.md is the closing ritual: before every session ends, the agent updates garden-state.md, captures observations about your planting patterns, flags seeds about to wilt, and updates its own memory.
This is why the GREENHOUSE remembers you between sessions.
Build the 5 skills that make the commands work
Skills are on-demand workflows triggered by commands. The 5 skills power the 4 commands, plus the onboarding wizard.
🪴 first-time-setup.md runs automatically the first time you interact with the agent when config status is UNCONFIGURED. You tell it “Help me with onboarding the greenhouse agent” and it asks where you capture ideas and where the garden should live, creates the directory structure, and hands off.
💐 greenhouse.md is the dashboard skill. When you say “GREENHOUSE,” it reads garden-state.md and renders the full dashboard: vital stats, active themes, ripeness tracker, convergence warnings, orphan watch.
🌱 plant.md is the entry point and the most complex skill. The agent checks what MCP integrations are available (Notion, Obsidian), then you throw something in without deciding. The agent reads garden-state.md, checks theme clusters, and determines if the input is a new seed or a signal to attach to something growing.
If you paste a URL with no note, the agent asks “what caught YOUR attention about this?” This is a key taste moment because the agent insists on your perspective.
The GREENHOUSE only reads from external sources, it doesn’t hunt for them. If you need a smart agent that gathers research and builds knowledge from outside, that’s WATSON. Different operation: one gathers, one tends. Both live in RobotsOS.
🌾 ripen.md is the harvest check. It reads the Ripeness Tracker, opens seeds sitting at 2+ criteria, and shows which criteria are met and which are missing.
The GREENHOUSE tells you “it’s missing Tension, answer the germination question about whether you agree with this or resist it, and it will ripen.” The criteria are encoded as conditions. When a seed crosses the threshold, the skill moves its file from seeds/ to ready/.
🍂 compost.md surfaces everything wilting (14 days no activity) or orphaned (10 days no connections) and presents each candidate with full context. You decide per seed: compost or revive. The agent cross-references new seeds against retired ones: “this new seed connects to something you composted in February.”
Rules give the GREENHOUSE consistent identity. It always behaves like a gardener, never a chatbot. Skills give it precise execution. Every command runs a specific, designed workflow rather than improvising from context.
The four commands you can use:
"Show me the greenhouse"—> dashboard and vital stats"Plant this"—> dual-mode entry (direct paste or sync from Notion/Obsidian)"Ripen"—> what’s closest to ready, with specific next actions for each"Compost"—> editing function, wilting/orphan review with cross-referencing
If the idea of breaking AI behavior into separate .md files is new to you, I wrote about what skills are and why this modular approach beats monolithic prompts.
Germination: How to capture the personal stake that makes ideas writable
The two germination questions are: “What made you notice this?” and “Do you agree with it or resist it?”
These questions serve real functions: personal stake and tension.
The agent wants to understand how YOU relate to the idea. Before the agent decides how to classify or connect a new idea, it wants to know if you’re fighting it or running toward it.
If you skip these questions, the seed gets planted without that context (not a deal breaker, since the agent can have access to your context, but it’s always good to answer these and give more context when you can!)
Here’s what a seed can look like:
# Life System with Claude Code
- ID: 001
- Status: seedling
- Planted: 2026-04-06
- Last activity: 2026-04-06
- Signals: 1
- Connections: none yet
- Ripeness: 0/5 criteria met
## Original signal
Building a life system with Claude Code — demonstrates using Claude Code to build comprehensive personal life systems and automation.
- Source: [Tweet]
- Synced from: Notion (Ideas page)
## Germination
## Attached signals
## Agent notes
Content angle: tutorial/showcase piece. Could connect to agent workflows, delegation, and automation themes.
## History
- 2026-04-06: Planted as seedling (synced from Notion)Ripeness: The 3-out-of-5 signals that say “harvest me”
The 5 ripeness criteria use a 3/5 threshold to ripen:
Signal Diversity (2+ different source types) —> means an idea that only comes from one source might be an echo.
Cluster Size (connected to 2+ other seeds)
Tension Present (unresolved question or contrarian angle) —> because an observation without a question is journalism, while an observation WITH a question is content.
Personal Stake (you engaged with it beyond planting)
Age Threshold (at least 14 days old) —> the most powerful principle. Patience is a feature and the GREENHOUSE rewards slow thinking.
This is the anti-reactive-content argument embedded in the architecture.
Before: you had a great shower thought, you captured it, you tried to write it the next day, it felt flat, you abandoned it.
After: the same thought, planted, left to collect signals, and 18 days later it connects to something from a client conversation and a piece you read and suddenly the angle is obvious.
Using the GREENHOUSE: Onboarding + real scenarios
The onboarding wizard starts when you point it to the folder you installed the agent in, and ask “Help me onboard the greenhouse agent.”
The agent asks where you naturally capture ideas (Notion, Obsidian, voice memo, direct typing). It confirms where garden data will live locally. If connected via MCP, it checks for Notion/Obsidian and offers sync.
You plant your first seed, the agent asks the germination questions. You answer or you don’t. The garden is alive.
Examples of what you can ask it:
“What is germination?” —> the agent explains why it asks what it asks.
“Suggest the best workflow between me and you so I can benefit from this at max” —> the agent designs a rhythm based on where you are in the process and your relationship to the GREENHOUSE (new, been using it for a while, etc).
“Tell me what I can do with you and what commands you have” —> the onboarding summary, delivered conversationally.
GREENHOUSE use cases:
The newsletter writer (me) does weekly planting from notes, client conversations, things that bothered me about AI content that week. The GREENHOUSE connects seeds across 3 weeks and surfaces the angle I didn’t see while planting.
The consultant plants fragments from client work (patterns they keep seeing, problems that repeat). After 4 weeks, the GREENHOUSE tells them they’ve been circling the same theme with three different clients.
The experienced professional plants ideas from 20 years of expertise in a non-AI field. The GREENHOUSE helps them realize they have 14 angles waiting, not zero.
Some design decisions I killed (and why they made the system better):
Why there’s one entry command, not two.
The original design had /plant for new seeds and /signal for raw material. I killed /signal. The whole point of a gardener agent is that it decides where things go. You throw it in, the agent sorts it. Having two commands put that cognitive load back on the user, exactly what the system is supposed to remove.
Germination happens at planting, not in a queue.
The first version had germination prompts that could accumulate and surface later. Plant five seeds in a week, get hit with 10 questions next session. I killed the queue. Germination happens immediately when you plant.
The file system IS the garden.
Early design had more abstraction, clusters as separate folders, signals as a staging area. I killed both. When you simplify the file structure to match the metaphor exactly, the agent gets simpler too. Seeds are files. Compost is a folder. The filesystem mirrors the gardening process, and suddenly every operation makes sense without explanation.
What the GREENHOUSE can’t do:
The GREENHOUSE cannot tell you what to write. It can tell you what’s ready to write.
The judgment of which ripened idea becomes your next piece is yours. The GREENHOUSE gives you a cleaner table to work from. You don’t get fewer decisions to make, just better-informed ones.
Also: it’s not passive. It learns. It tracks how you use it and calibrates. But it never pushes. It waits until you show up.
You have everything you need to build the GREENHOUSE yourself this weekend
Open Claude Code or Codex, and use this prompt:
I found this article that describes an AI agent called the GREENHOUSE, an idea-tending agent that tracks your half-formed ideas over time, cross-references them, tells you when they're ready to become content, and adapts to how you work. I want to build my own version. Please read the article carefully, extract the full architecture (directory structure, all rule files, all skill files, commands, ripeness criteria, composting logic, and user pattern tracking), then help me build it step by step, starting with the file structure and working through each file until the agent is complete and ready to onboard me.
[PASTE THE FULL ARTICLE HERE]If you’re a PREMIUM ROBOTS subscriber, download the GREENHOUSE directly from RobotsOS and start using it in under 5 minutes:
Point Claude Code (or Codex, or whatever platform you use with your agents) to the GREENHOUSE folder and type “Help me with onboarding the greenhouse.” That’s it.
Besides all the tech stuff you learned, this is a reminder to slow down and plant one seed. One thought that’s been nagging. Not in the GREENHOUSE yet, just in a new note, typed out, with the two germination questions answered.
“What made you notice this?”
“Do you agree with it or resist it?”
You can do it manually, right now, and feel the difference between capturing and tending.
To the seedlings you almost composted,
Chief 🤖 at ROBOTS ATE MY HOMEWORK
"A seed is a thought with no connections yet"
I love how you've made the correlation of the growth and coordination of nature to agent.
It totally reminds me of my flower framework haha,
it all begins with a seed--the idea.
and ends with how gracefully everything works together towards the blooming vision ❤️ 😁
Most of my plants die
I need your help on both fronts :)