TL;DR

Project management assumes you know where you're going. I don't always know that. After AI made previously impossible ideas suddenly possible, traditional note-taking and planning broke down under the weight of expanding possibilities.

Grove is the response: a system that treats ideas as seeds rather than tasks. You plant desires ("I want X"), add context over time, and let them crystallize into executable intents. Intents form a dependency graph. Strategic priorities (e.g. acceleration, sustainability, intelligence) with adjustable weights help determine the order of execution. Change the weights, see a different future.

Unlike agent orchestrators that are optimized only for throughput, Grove helps you decide what to do when priorities are uncertain—then execute with precision once decided. It's currently personal infrastructure, deeply integrated with my NixOS setup. Not racing to market. Looking for collaborators and/or aligned funding, not users or hype.

Origins

The phrase "project management" names a kind of violence. You take living work—the mess of intentions, half-formed intuitions, ideas that haven't found their shape—and you flatten it into rows in a backlog. The assumption is always that you know where you're going. Track whether you got there.

I don't always know where I'm going.

For fifteen years I used org-mode. This was fine. Then something started waking up in the machines, and what had been fine became insufficient.

AI Whiplash

I'd been building a framework for local-first applications—software that runs where you are, syncs when it can, belongs to no one but you. Still in the pipeline. More on that another time. When Claude touched down, ideas I'd abandoned as impossible or impractical seemed to move within reach. The decades-old dream of human-computer symbiosis was materializing for anyone paying attention.

I extended my notes. I prompted the Claudes to generate plans, maintain context across sessions. Documents fed into documents. Things got built.

But I was drowning. My monorepo filled with markdown files. I couldn't answer a simple question: where should my attention go next? I started dreading opening my laptop. I thought about burning it down, starting smaller, something I could control.

I was thinking like a manager, not a gardener.

Clearing

At a conference in San Francisco, a couple of mad scientists @cdata and @gozala presented a database built on triples—subject, predicate, object. The primitive of meaning itself. It could sync without servers, query relationships, travel through time. Their friend mentioned building something open-ended on top of it, something about dialogical design.

I only half-understood. But it got some ideas flowing. A month later I started building, and within a week the thing had its own momentum. Ideas started arriving faster than I could implement them. I was taking dictation.

Introducing Grove

David Lynch said forgetting an idea might make you want to kill yourself. Crip Mac said never commit suicide. Both true. The solution is to write everything down.

But there's a gap between having an idea and an idea becoming real. Notes get lost. Digital notes get lost differently. What you want is a way to add detail to ideas until they become executable—until they want to execute.

A garden is not managed. You create conditions. You observe. You intervene sometimes. Things die. This is fine.

I build with seeds. A seed is something you want. "I want my documents to sync across devices." "I want to know where my time goes." "I want to coordinate agents without losing my mind." Seeds don't specify implementation. You plant them. You tend them. You add context. Eventually something crystallizes—a shape clear enough that one could pick it up and run with it.

These crystallizations form a directed acyclic graph. Some must come before others. Some can sound simultaneously. Priority determines which voices speak first, which wait. Ordering requires strategic priorities: reasons why one intent matters more than another right now.

My current strategic priorities:

• Acceleration: work that compounds, infrastructure that speeds up future work

• Sustainability: work that might eventually generate income

• User value: work that helps someone other than me

I weight them. Currently: 60/30/10. An agent scores each crystallization against each goal. The weighted sum determines what surfaces, what gets voiced next.

Change the weights and watch the graph reorganize. "What if I focused entirely on momentum?" becomes a question with an answer. You explore futures without committing to them.

The Difference

Steve Yegge built Beads, an issue tracker for agents, then Gas Town—an orchestrator that scales to thirty agents running simultaneously. It's optimized for throughput but at the moment seems too chaotic for my liking.

Apologies to everyone using Gas Town who is being bitten by the murderous rampaging Deacon who is spree-killing all the other workers while on his patrol. I am as frustrated as you are. Fixes incoming in v0.4.0, but for now, please run your town with no Deacon.…

— Steve Yegge (@Steve_Yegge) January 8, 2026

In his article introducing Beads, Steve wrote that humans track nested work mentally because "you know where you're going and where you've come from." His tools help agents execute on that assumption.

I don't always know where I'm going. When work gets deep enough, when possibilities multiply, I can lose the thread. I begin to make decisions based on what seems good in the moment. This works until it doesn't.

I wanted something that helps me decide and then execute based on past decisions when the time is right. Given limited attention and uncertain priorities, what should I start doing next?

Project management won't answer that. Project management assumes the score is written and tracks whether the orchestra played it correctly. When the composition itself is what you're trying to figure out, you need something else.

Grove is a single interface designed to help you capture ideas, make good decisions, refine plans, and then execute them with speed and precision.

Current State

This runs on experimental foundations. Things break. I use it daily. It is not ready for people who expect polish.

It's also entangled with my operating system. Each intent that you execute gets its own workspace, its own windows. You recall them with keystrokes or by touching the graph. A productized version would need to be self-contained—but there are advantages to deep integration that only exist when your OS is hackable, and I want those advantages before I worry about accessibility.

What's Next?

I am not racing to market.

The foundations need time. Shipping product on unstable dependencies creates support burden. I can't afford that alone.

I considered alternatives. Ship fast, iterate—standard advice, but when dependencies shift you debug upstream problems while supporting customers. Build something smaller first—but if what I build doesn't improve my own process, I'm wasting time in a field that's changing faster than I can track.

I chose: wait. Build for myself. Share with others working on similar problems. Let dependencies mature. Use the tools to build other things. Commercialize later, maybe.

I don't want the VC model. I don't want growth metrics or hype cycles. I want to build things that solve real problems, feel inevitable to use, and don't require exploitation to sustain. I believe people will pay for something like this. Eventually.

What I'm Looking For

The code is not public at the moment, though get in touch if you're interested. I prefer to keep the circle small, build relationships, find collaborators rather than users.

If you work on local-first systems, agent coordination, or something adjacent—if you recognized something in this—reach out. I'm setting up infrastructure for sharing. I'll give access to anyone who wants to look.

I would also accept funding that enables proper open-sourcing. Sponsorship. Grants. Arrangements that align incentives without requiring growth optimization. If you want to support local-first tooling or agent coordination infrastructure, we should talk.

I stream development sometimes. Subscribe for more updates.

The garden doesn't care about your timeline. It just wants to grow.