The Ecosystem · 2025–present
Reloop
The competitor is not another app, it is the open loop itself, the unfinished thought that taxes a mind in the background.
A place to put an unfinished thought down, so that it stops running in the background: held, ripened, and handed back only at the moment it can actually be acted on.
Reloop's Dashboard, a surfaced loop about an expiring permit shown with its stage track from dumped through digesting and maturing to surfaced, above two more loops still maturing and acting.
The rent
None of it is hard. All of it is resident.
Renew the insurance. Send the accountant the documents. Decide about the school before the deadline. Each of these is twenty minutes of ordinary adult life and none of them is difficult. What costs is that they are open, held in a mind that will not put them down, because putting something down requires somewhere trustworthy to put it.
-
Nowhere trustworthy to land
A mind does not release what it does not believe will come back. Paper is lost, a note is never reopened, and a name in a list is only a different place to worry about the same thing. Without a credible return, the safest place to keep a loop remains your own attention.
-
The list is another thing to manage
Task apps move the load rather than remove it. Now there is a list to file into, groom, and reread. And rereading it means confronting every open item to find the two that matter today. Maintenance of the tool becomes part of the load it was meant to lift.
-
Answers that open more loops
Ask a model and you get five options, a comparison table, and a decision you did not have before. Research was never the hard part; almost every one of these loops could be resolved in an afternoon by someone with the bandwidth to start.
-
The right thing at the wrong moment
Information delivered before it can be acted on is noise, and noise teaches you to stop looking at the channel that sends it. A renewal notice in January for a policy that lapses in June trains the same reflex as spam.
-
Nothing holds any state
Every tool starts from zero. An answer is useful only in context: what you decided last year, who already handles this, when you actually do this kind of thing. All of it has to be supplied again from scratch, by the person with the least capacity to supply it.
-
The cost is interest, not work
Not starting is rarely laziness. It is a mind whose executive function is already committed elsewhere, paying a background charge on items that produce nothing while they stay open. The charge accrues all day and shows up as guilt rather than as a line item.
The contradiction underneath
The reframe
The competitor is not another app. It is the open loop.
Productivity software competes on features against other productivity software, which is the wrong opponent. Nobody abandons a task list for a better task list; they abandon it because the loop went back into their head. The thing worth beating is inaction itself, and the honest measure is not how much the product gets used but how much less the person is carrying.
The person dumps, and the person acts. Everything between those two verbs belongs to the system.
The second reframe: built for the mind with the least slack
Most tools are designed for a well-regulated attention and made accessible afterwards. This one starts at the other end. The primary case is a mind whose executive function is already fully committed: ADHD, autistic, depressed, exhausted, or simply deep in a hard quarter. For that mind the distance between knowing what to do and beginning it is the whole problem rather than a detail. A design that works there works everywhere; the reverse is not true.
That inverts what capture is allowed to cost. If putting a loop down requires a project, a category, a due date and a priority, it will not happen on the day it is most needed, because choosing four fields is precisely the act the person has no capacity for. So a dump is one sentence and nothing else. Structure is the system's job, performed afterwards, out of sight. That is only possible because structuring is cheap for a machine and expensive for a tired human, the exact inversion the design is built on.
The loop's life
Six states, and you are present for two of them.
A loop is not a task. It has a life: dumped in a hurry, understood, left to ripen, brought back at a moment when it can be acted on, acted on, and closed. Naming those states is what makes it possible to take the middle of that life away from the person. Two more exist off the line: parked, for the ones with no urgency at all, and recurring, for the ones that come back by their nature.
Dumped
One sentence, typed into a box, at the moment the thought appears. No category, no date, no project. The only promise that matters is made here: that it will come back. Everything else in the design exists to make that promise credible enough to let go of.
the person
Digesting
The sentence is read for what it actually is: something with a deadline, something requiring a decision, something to track over time, or a someday. At most a question or two back, never a form. This is where a fragment only its author could decode becomes a loop the system can hold.
the system
Maturing
Most loops should not be looked at yet. Maturing is a real state rather than a backlog: the loop is held, waiting on a date, on information, or simply on not being urgent. Nothing is asked of the person while it ripens, and nothing is shown to them either.
the system
Surfaced
The judgement the whole system exists to make: this one, now. Too early and it is noise, and noise teaches the person to stop trusting the channel; too late and it is a missed deadline. Timing is not a feature here, it is the product, and it is the thing a person is worst at doing for themselves.
the system
Acting
The loop returns narrowed to something decidable. The person decides, redirects, or defers. Deferring returns it to maturing rather than to a pile. This is the second and last moment anything is asked of them.
the person
Closed
A loop that ends is not archived. It is closed, the state the whole cycle is named after. What it leaves behind is evidence: how long this kind of thing actually took, when this person deals with things, what was decided and why, so the next loop of the same shape can start further along.
the system
Architecture
Three planes, and only one of them is built.
This is the youngest work in the studio and the one with the least code behind it. The shape it needs is worked out and drawn; most of it has not been written. Saying plainly which is which seems more useful than a page that reads as though it had.
Three planes, one of them real
The division is the same one the three sibling ecosystems use, cut for a different problem. What persists here is not a résumé or a rhythm but an operational profile: how this person decides, when they actually deal with things, what they already have running, who else depends on them. That plane is the reason a surfaced loop can arrive narrowed instead of open: the narrowing is done against context the system already holds, which is exactly what a stateless assistant cannot do at any price.
Digestion is the plane the promise rests on, and it is the plane that does not exist. Its module names are in place: capture, digest, surface, signal, profile. The files behind them are empty. That is an honest description of the current state rather than a roadmap: there is no engine, and nothing on this page should be read as though there were.
One loop, end to end
Drawn as a line, the argument gets blunt. Everything between dumped and acting is work that currently happens inside a person's head, and none of it is work a head is good at. Holding something indefinitely, structuring it, remembering it unprompted, and choosing the right moment to raise it are four things attention does badly and a system does cheaply.
It also explains why closing carries weight rather than being a delete. A loop that is merely removed teaches nothing. A loop that closes deposits the only thing that makes the next surfacing better: evidence about how this particular person, not people in general, deals with this particular kind of thing.
What exists today
A desktop application in Tauri and React, the same stack as the three siblings, with six surfaces built against the model above: a dashboard, the loops with their stage track, the profile, signals, alerts and settings. A capture box that takes a sentence and nothing else. And the interface's one finished idea: there is no light or dark switch, because the interface follows the solar cycle instead. A tool opened at seven in the morning and at eleven at night should not arrive in the same register both times.
Behind it is a fixture compiled into the bundle: three invented people and their loops, which is what the screenshot above is showing. There is no digestion engine, no timing engine, no persistence and no account. The argument, the state model and the front end are real; the intelligence is not written. It is published here as a design with its front half built, which is the accurate description and the only one worth making.
- the appTauri v2 desktop shell, six surfaces (built)
- captureone box, one sentence, no fields (built)
- loop modelsix states plus parked and recurring (specified and rendered)
- circadianthe interface follows the solar cycle, no theme toggle (built)
- digestiondump → structure → enrich → time (drawn, not written)
- profilethe operational context the narrowing depends on (drawn, not written)
- signalswhat closed loops teach about this person's timing (drawn, not written)
The measure
Working, it looks like less.
Every convention in this category measures the thing this system is trying to reduce: sessions, streaks, minutes in app, the small red number. If those go up here, something has gone wrong. The only honest report a cognitive offload tool can make is about absence. And absence is difficult to sell, which is the whole reason it is worth building outside a business that has to.
An empty Reloop is not an unused Reloop. That sentence is the product philosophy and also its commercial problem. If the interface is quiet on a Tuesday, either nothing arrived or everything was handled, and both of those are the success case. So the interface is built to breathe rather than to fill: as loops close it becomes emptier, slower and more spacious, and the emptiness is not a lack of content but a report on how much attention has been handed back. It is the anti-engagement product by construction, which is precisely why it belongs to a studio and not to an industry that has to measure the opposite.
Designing for the mind with the least slack has a second consequence beyond one-sentence capture. It changes what the system is allowed to ask for at every point. It may ask a clarifying question at digestion, because the person is already there. It may not ask them to organise, to prioritise, to review a backlog, or to decide when something should come back. Those are the four requests that quietly return the whole load. Executive function, on this reading, is not a fixed personal trait but something an environment can lend or tax. Most software taxes it. That is the studio’s definition of an inhabitable interface: a space that gives capacity back rather than borrowing it.
Among the four ecosystems this studio keeps, Reloop is the operational one and the only one designed from the start for someone other than its author. Continuum is where work persists, Ciclus is where a life is sustained, Compass is where a career navigates. Reloop is the plainest of the four: the friction of ordinary administration, the part of being an adult that consumes attention without ever being the thing you meant to spend it on. It is deliberately not Ciclus. That one is intimate, concerned with sleep and rhythm and the body. This one is bureaucratic, and the two loads are carried by the same person in entirely different registers.
It is also the least built. What exists is an argument, a state model and a front end; what does not exist is the engine that would make the promise true. That ordering was deliberate rather than accidental. The hard part of this product was never inference. It was deciding what a loop is, when it deserves to come back, and what a person must never be asked to do. That part is finished, and it is the part published here. The rest is writing.