AWS Builder Center
Rethread: the part of ADHD that software usually gets wrong

Rethread: the part of ADHD that software usually gets wrong

Rethread helps you get back into work after an interruption. Set a session, get one concrete first step, and when you return, agents rebuild what you were doing, the tabs that mattered and the next move. Every support it offers runs as a single-case experiment before it claims anything.

Student
There is a specific moment we built this for. You are forty minutes into something. Someone calls, a message arrives, a tab pulls you sideways. When you come back, the goal is gone. Not forgotten exactly, but no longer loaded: which document was the one that mattered, what you had decided two steps ago, what the next actual move was. Rebuilding that takes minutes, and quite often the session just ends there.
Russell Barkley's framing is that ADHD is a disorder of performance at the point of performance, not of knowledge. People know what they should be doing. What breaks is the doing of it, and an interruption is the cleanest possible demonstration: working memory drops the thread, and no amount of knowing helps you pick it back up.
Most tools answer this with reminders, streaks and advice. All three tell you what you already know, and the streak adds a running count of your failures on top. We wanted the opposite: something that lowers the cost of restarting, and then finds out what actually helps this one person instead of offering generic tips.
That is Rethread. A Chrome extension and a dashboard, built over four days by two people on AWS.

What it does

You set a session: what you are working on, where it lives, when it is due. An agent turns that into one physical first step, plus a couple of if-then plans for the moments it tends to stick. Not a to-do list. One move.
Then you get interrupted, because you will. When you come back, a re-entry agent reconstructs the thread from the session's goal and the titles of the tabs you visited: what you were doing, which tabs were part of it, the one next action, and the evidence it used to decide. No focus score, no verdict on your afternoon. It hands back the work.
Overnight, a second agent looks across the past week and names what the tabs show. Slow starts. Circling back to the same page. Rechecking messages. Spreading across too many tabs at once. It picks one evidence-based if-then plan for tomorrow and tells you why that one: which executive function domain it targets, where it comes from, and when a clinician would not use it.
And there is a small guide chat that answers questions about ADHD and getting unstuck, only from a fixed index of trusted sources, with safety routing that runs before any model call.

Three rules we would not break

Support, not assessment. No screening, no diagnosis, no severity scores, no medication content, no repurposed rating scales. Naming ADHD as the audience is intentional. Assessing the user is not. The clinician stays the decision maker, and what the tool produces is objective data the user owns and can choose to share.
No shame loop. No streaks, no red, no failure framing. A missed session is a data point about conditions, not a verdict on a person. This is enforced in code: every model output that reaches a user is checked for language about the person, and rejected if it appears.
Privacy in the data model, not the privacy policy. The extension captures tab title, domain and time. Never page content. The tab timeline is never stored on the server, and experiment records hold measurements only, with the goal text stripped before anything is logged.

The architecture, and the rule behind it

The whole backend is one AWS Lambda behind a Function URL. One action routed handler serves fourteen actions: first move, drift, churn, re-entry, session chat, condition assignment, session logging, nightly analysis, friction check, feels heavy, guide, the opening turn, and saving and listing sessions. One deploy, no idle cost, no API Gateway, and one cold start paid for everything.
Agents are built with the Strands Agents SDK and run on Amazon Bedrock. The Lambda mints short lived Bedrock tokens from its own IAM role, so no model API key exists in our code, our config or our public repo.
The rule we designed around: use a model only where language is needed, and compute everything else. Churn detection, the four friction detectors, condition assignment, the statistics and the guide's safety routing are all plain code. That is not a cost optimisation we bolted on at the end. It is what makes the system checkable. You can test a permutation test. You cannot test a judgement buried in a prompt.
Where a model is used, its output is validated before anyone sees it, gets exactly one repair attempt, and falls back to a safe deterministic template if that fails. Every agent call starts with an empty conversation, so a warm Lambda container never carries one user's tabs into another user's call.
State lives in one DynamoDB table keyed by user. Sessions, experiment records, the latest analysis. That is the architectural point we would make out loud: agents that remember weeks, not one conversation. It is also why a session you start on a laptop continues on your phone. An EventBridge schedule runs the nightly analysis for every user, Cognito handles sign in with the token verified inside the Lambda, and Amplify builds and serves the dashboard from GitHub on every push.

Where the rigour lives

Single case experimental design is a real clinical research method, and we treated it as one.
Each session is assigned a condition in balanced, shuffled blocks seeded by the user's Cognito id, so the conditions cannot line up with someone's routine the way simple alternation would. The outcome is initiation latency: seconds from starting a session to the first tab that is genuinely part of the declared work, as judged by the drift agent. A failed check is recorded as missing, never as a start.
Nothing is reported until each condition has eight sessions. Then an exact permutation test at alpha 0.05 decides, and the answer is one of three honest ones: still learning, no clear difference, or a finding. Only a finding reaches the analyst agent, whose wording is validated before it is shown. There is no code path from data to a user facing claim that skips the gate.
Sitting at "still learning, 0 of 8" through an entire build, with a demo coming, is a standing invitation to lower that bar. We kept it. One consequence we did not plan for: sixteen real sessions take a fortnight, and we did not have one, so our walkthrough runs on seeded sessions. The gate, the test and the write up around them are the real ones.

Four days, three people, and what we got wrong

The measurement mattered more than the model. Our first definition of time to get started was the first tab captured after a session began, which meant opening YouTube counted as starting work. Every number downstream was quietly wrong. Redefining it, and recording a failed check as missing rather than as a start, changed the whole experiment.
Validators beat prompt engineering. We spent the first day adding rules to prompts. No praise, nothing about the person, no invented filenames. The model kept finding ways around them. What held was deterministic: check the output, ask for one repair, fall back to a template. The prompts got shorter afterwards.
Browser storage is per origin. Sessions lived in localStorage, so the copy on localhost and the copy on the deployed site were separate worlds. Ten minutes before a demo, that looks exactly like data loss. Moving sessions into DynamoDB under the Cognito id fixed it and gave us something better than we had planned: sessions that follow you between devices.
An honest empty state is a feature. Our friction check ran once a day, so a session that ended after that day's run was not looked at until the next morning, while the panel said "nothing recurring" and sat on new data. It reads as broken. Two small changes fixed it: look again whenever there is new data, and say plainly whether the answer is "nothing to read yet" or "nothing recurring".

What is next

Time limited clinician sharing with Cedar policies, so a user can grant read access to their experiment data for a set period and revoke it whenever they want. Step Functions for a weekly experiment cycle that fans out per user. More conditions to test: session length, time of day, deadline framing. And full export and delete from the dashboard, because data you own should be data you can take with you.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article