LockedIn Is an Attention Operating System and I'm Here to Sell It to You

Let me ask you something. How many productivity apps are on your phone right now? And how many of them have you opened in the last week? Be honest.

Here's what I suspect. You have a habit tracker, a to-do list, a Pomodoro timer, maybe a focus music app. They all looked great in the App Store screenshots. They all promised focus. And somewhere around day three, they all became icons you scroll past, feeling vaguely guilty.

I built a lot of those apps myself, mentally. And I kept noticing the same two failures:

Passive timers lie to you. A timer tells you how long you sat there. It does not tell you that you spent 40 of those 50 minutes fighting the urge to open Twitter. It measures chair time, not attention.

Gamification is mostly theater. Badges for showing up are meaningless. Anyone can brute force 50 hours of distracted sitting. Nobody can fake a fast comeback after an escape.

So I stopped trying to build the 13th to-do app and built something else instead. LockedIn, an Attention Operating System. This post is the sales pitch. Buckle up.

The One Idea Everything Runs On

Every single thing that happens to your attention is an event. Starting a focus session is an event. Pausing is an event. Completing a task is an event. Resisting an urge to check your phone is an event. Escaping to go doomscroll is an event, and so is the 11 minutes it took you to come back. Saving a random curiosity in your head so you don't have to tab out is an event.

LockedIn records all of it in one chronological Timeline Feed. Not scattered across tabs, not in some buried settings panel. One stream that tells the true story of your day:

08:00 Started Focus
     Java Backend, Lecture 18

08:42 Wanted to check Twitter
     Ignored, +15 XP

09:05 Short Break

09:12 Started Focus

09:44 Escaped
     Reason: didn't understand the topic
     Came back after 11 minutes

10:06 Curiosity Saved
     "How does Redis persistence actually work?"

11:18 Completed Lecture 18
     Flow 4/5, felt okay

Under the hood, it's embarrassingly simple. Every single action in the app ends up calling one function that prepends a new event to the stream:

addEvent: (type, title, subtitle, metadata) => set((state) => {
  const newEvent: TimelineEvent = {
    id: `ev-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`,
    timestamp: new Date().toISOString(),
    type,
    title,
    subtitle,
    metadata: { ...metadata, brainState: state.brainState },
  };
  return { events: [newEvent, ...state.events] };
}),

One function. The timer calls it, the task manager calls it, the urge logger calls it, the escape prompt calls it. Analytics, XP, streaks, and the reward vault all read from the same stream instead of maintaining their own little counters. No duplicated state, no drift, no data that has to be reconciled later.

Notice what's missing. No judgment, no streak that guilt-trips you. Just data. Because you cannot fix what you cannot see, and most people have never actually seen their attention in action. This feed is the closest thing to an honest mirror I've ever built.

The Brain States and the Honest Parts

My favorite feature is the one most productivity apps would never ship: the Escape Log.

LockedIn asks you to track your brain state, Focused, Planning, Seeking, Escaped, Burned Out. And when you inevitably slip out of focus, it stops being polite. A prompt appears. Why did you step away? Phone. Social media. Didn't understand the task. Restless. Family. Sleepy. Other.

Then it measures your restart latency, the exact time from losing focus to getting back. And here's the part I'm genuinely proud of: it rewards the recovery, not just the streak. Come back within 2 minutes and you get a big fast comeback bonus. The app is designed to make the return faster, not to punish the departure. Discipline is a loop, not a state.

In the store, every brain state carries an XP multiplier, and escaping is brutal on it:

setBrainState: (state) => set((prev) => {
  let multiplier = 1.5;
  if (state === 'FOCUSED') multiplier = 2.0;
  if (state === 'PLANNING') multiplier = 1.5;
  if (state === 'SEEKING') multiplier = 1.0;
  if (state === 'ESCAPED') multiplier = 0.5;
  if (state === 'BURNED_OUT') multiplier = 0.8;

  if (state === 'FOCUSED' && prev.lastEscapeTimestamp) {
    const latencySeconds = Math.max(5, Math.round((Date.now() - prev.lastEscapeTimestamp) / 1000));
    get().addEvent('focus_start', 'Focus Session Started', prev.pinnedMission || 'Deep Focus Block', {
      restartLatencySeconds: latencySeconds,
      xpEarned: 75
    });
  }
}),

And the escape itself is its own event, timestamped and logged with the reason:

recordEscape: (reason: string) => {
  const now = Date.now();
  set({ lastEscapeTimestamp: now, brainState: 'ESCAPED', momentumMultiplier: 0.5 });
  get().addEvent('escape_logged', 'Escaped / Interrupted', `Reason: ${reason}`, { escapeReason: reason });
},

The math is honest. You cannot game the system by logging everything as Focused, because the escape event still hits the ledger, the multiplier still drops to 0.5x, and the analytics still call you out on Thursday.

XP That Actually Means Something

Most gamified apps hand out XP like candy at a parade. LockedIn calibrates the economy around what the app's design doc calls "attention quality":

• Complete a standard focus session, 25 XP
• Complete a 60 minute deep work block, 75 XP
• Resist a distraction urge, 15 XP
• Fast comeback under 2 minutes, 75 XP
• Perfect day with zero escapes, 2x multiplier

Notice the pattern. Resisting an urge is worth more than sitting through a shallow session. Recovery is worth as much as the work itself. You level up, you climb from Beginner to Deep Worker to Flow Master to Master of Focus at level 100. But the rank is earned, not gifted. You cannot sleepwalk to Flow Master.

The level curve is deliberately unforgiving:

function xpForLevel(level: number): number {
  return Math.floor(200 * Math.pow(level, 1.2));
}

function getLevelFromXP(xp: number): number {
  let lvl = 1;
  while (xpForLevel(lvl) <= xp) {
    lvl++;
  }
  return lvl;
}

Early levels come fast to hook you in, then the curve starts demanding real attention hours. And notice the multiplier sneaking into every award:

addXP: (amount, reason) => set((state) => {
  const totalAmount = Math.round(amount * state.momentumMultiplier);
  const newXP = state.xp + totalAmount;
  const newLevel = getLevelFromXP(newXP);
  const newRank = getRankTitle(newLevel);

  get().addEvent('xp_earned', `+${totalAmount} XP Earned`, reason, { xpEarned: totalAmount, multiplier: state.momentumMultiplier });

  return { xp: newXP, level: newLevel, rankTitle: newRank };
}),

Every XP award is multiplied by your current brain state multiplier before it lands. Your level only moves when your focus actually moves.

The Reward Vault, a Permission Engine

Here is the feature I would steal from myself if I could. The Reward Vault.

You create real-world rewards and attach objective requirements to them. Not vibes, numbers. Requirements.

• Pizza night: complete 5 straight focus days
• That mechanical keyboard you've been eyeing: log 100 hours of Learning, Backend
• Play Elden Ring guilt free: finish the weekly challenge

LockedIn acts as the permission giver. The vault stays locked until the milestones are hit. This turns procrastination on its head. The thing you want isn't the enemy of your focus anymore, it's the prize. You're not denying yourself the reward, you're earning the right to enjoy it without shame.

The vault runs on one hard rule, no check, no unlock:

buyReward: (id) => {
  const state = get();
  const targetReward = state.rewards.find(r => r.id === id);
  if (!targetReward || targetReward.isUnlocked) return false;

  const availableXP = Math.max(0, state.xp - (state.spentXP || 0));
  if (availableXP < targetReward.xpCost) return false;

  set((s) => ({
    spentXP: (s.spentXP || 0) + targetReward.xpCost,
    rewards: s.rewards.map(r => r.id === id ? { ...r, isUnlocked: true, unlockedAt: new Date().toISOString() } : r)
  }));
  return true;
},

That early return false is the whole product. No milestone met, no XP in the bank, the function quietly refuses and the vault stays shut. I've stared at that false return more times than I'd like to admit.

The Mini-HUD That Follows You Around

The one feature people react to the most is the floating Mini-HUD. LockedIn can pop out a tiny, always-on-top window using the browser's Picture-in-Picture API that stays visible over your IDE, your terminal, your PDF viewer, your entire desktop.

You get the giant countdown, the pinned mission for the session, and a one-tap urge logger, all floating above your code. And it gets out of the way: adjustable opacity down to 10% ghost mode, click-through mode with a hotkey, even an AMOLED mode with micro pixel-shifting to protect your screen from burn-in. Because yes, I thought about your OLED display while you were thinking about your deadline.

The Vibe, Because Focus Should Feel Good

This is the part I'm unapologetic about. If you're going to spend hours in an app, it should feel like a place you want to be. LockedIn's focus workspace is full-screen ambient: animated backgrounds, a multi-channel soundscape mixer where you can blend rain, cafe chatter, and brown noise to your exact taste, and a daily quote engine. No clutter, no sidebar screaming at you. One pinned mission, one timer, one decision to make.

That's the One Decision Rule. You pin a single non-negotiable mission before you start, and it stays on the screen the entire session. No choosing between 14 tasks mid-focus. Decision fatigue is how focus dies, so the app removes the decision.

Built Local-First, Because Your Attention Data Is Yours

You can use LockedIn as a guest with everything stored locally, zero login, zero telemetry. Sign in with Google or GitHub if you want sync. The app is a PWA, installable, offline-capable, and the entire architecture was designed around the idea that your attention history is a private ledger, not a product to be mined.

The Pitch

So here's my honest pitch. You don't need another timer. You need a system that sees when you escape, rewards you for coming back, and makes the things you actually want to do the rewards for the work you actually need to do.

LockedIn is live right now at lockedin-vert.vercel.app. Full honesty: it's in beta, and yes, there's a waitlist. I'm not going to dress that up. The waitlist exists because I'd rather onboard people in small waves and actually read their feedback than hand everyone keys to something half-baked. Join it, get in, pin one mission, and start a 25 minute session. Your timeline will thank you.

And if you're wondering whether this is yet another app you'll abandon by Friday, that's exactly why the app keeps the ledger. Check your timeline in a week. The data won't let you lie to yourself.

Your attention is the only currency you can't earn back. Spend it like you audit it.