The AI That Decides What You Can Browse

Every focus app that blocks websites has the same problem: the list. Someone has to decide what's on it. That person is usually you, which means you make the decision when you set up the app — calmly, rationally, in a low-stakes moment — and then your future distracted self finds seventeen workarounds.

Static blocklists also can't reason about context. Is YouTube a distraction? It depends entirely on what you're doing. If you're writing a legal brief, yes. If you're editing video, it's your research library. A list can't know the difference. You have to maintain separate profiles, toggle lists on and off, and spend mental energy managing your tools instead of doing your work.

We built something different.

A judge, not a list

When you start a session in 45, you describe what you're working on in plain language. "Write the Q3 board deck." "Fix the auth bug in the API." "Research suppliers for the new product line."

That description becomes the context for every decision the app makes during the next 45 minutes. When your browser requests a domain, 45 evaluates that domain against your task — not against a list — and decides in real time whether to allow it or block it.

The evaluation is done by a small, fast AI model (GPT-4o-mini) running through our backend. The prompt looks roughly like this:

For "write the Q3 board deck", reddit.com is blocked. But if your task were "research community sentiment on our product launch", it might be allowed. The AI reads the task, reads the domain, and makes a judgment call — the same one you'd make if you stopped to think about it.

What actually gets sent to the AI

We're deliberate about what leaves your machine. The only data sent to the AI model is:

1. Your task description. The plain-text string you typed or spoke. Nothing else about you, your identity, or your history.

2. The root domain being evaluated. Not the full URL — just the domain. So "github.com", not "github.com/yourcompany/privaterepo/pull/143".

That's it. Two strings, one prompt, one JSON response. The model doesn't know who you are, what company you work for, or what you did in previous sessions.

The infrastructure that never calls the AI

Most browser activity isn't decisions — it's plumbing. When you load any modern website, your browser makes dozens of requests to CDNs, analytics services, font providers, and authentication endpoints. Evaluating each of these with an AI call would be slow, expensive, and pointless.

45 handles this with two pre-AI filters. The first is an infrastructure allowlist: known CDNs, SSO providers, and asset hosts that are always safe to pass through (Google Fonts, Cloudflare, Stripe's payment widget, etc.). The second is a noise filter: analytics trackers, ad networks, and telemetry services that are always silently blocked without cluttering the decisions feed.

Only domains that aren't in either category — domains you might actually be navigating to — reach the AI. In practice, that's a small fraction of total requests, and each new domain is only evaluated once per session. The result is cached for the rest of the 45 minutes.

Why it works where lists fail

The core advantage of per-task AI evaluation is that it scales to any task without configuration. You don't maintain lists. You don't create profiles. You type what you're working on, and the right sites are available — not because you set them up, but because the AI understands the task.

When you're doing outreach on LinkedIn, LinkedIn is allowed. When you switch to writing documentation, LinkedIn is blocked. The app adapts to your work without you touching a setting.

The failures of static blocklists — the workarounds, the wrong-task profiles, the cognitive overhead of managing your own rules — disappear because there are no rules to manage. There's just your task, and a model deciding what's relevant to it.

We think this is the only architecture that actually works for knowledge workers whose tasks change every session. Everything else is just a slightly fancier list.