Why I left Amazon, and what I'm building

I've been working on Toolscaled on the side for a long time. In May I quit my job at Amazon to work on it full time.

Toolscaled

Toolscaled starts with an agent. You work through a task with your agent until you get what you want. Then you convert that session into a workflow you can run again.

The workflow has some big advantages over the original session:

  • It's faster. Most steps don't need a model at all. Toolscaled queues them and runs the independent ones in parallel.
  • It's cheaper. The few steps that need a decision can use a smaller, cheaper model.
  • It does the same thing every time. The steps are fixed, so there's no agent improvising and making mistakes.
  • It's easy to fix. When something goes wrong, you load the run into your agent, and it already has the context to continue. So the whole system gets better one run at a time.

On top of that come triggers: an email arrives, a cron schedule fires, a Slack message comes in, and the right workflow runs. All of this runs inside an agent, and there's also a website where you operate and watch everything.

Three tools inspired it:

  • n8n shows there's demand for workflows. But look at the job postings: lots of companies are hiring people just to build n8n workflows. Drag and drop or code, somebody still has to configure it.
  • Zapier is the glue for tons of businesses. It's great for simple stuff. But you set up each step by hand, and once a process gets complicated, it falls apart.
  • OpenClaw shows what people really want: AI agents that do stuff without needing a human for everything. But OpenClaw is a security nightmare, and it builds the system itself. That system turns into a spaghetti-code mess that you now have to maintain. Do you really want to spend your time having your system fix itself? And do you want to let loose an LLM with no guardrails? It also gets expensive if you use the latest models, and really stupid if you use cheaper ones.

Toolscaled tries to take the good parts of all three. It starts with an agent. When you get what you want, convert it to a workflow. Use LLM steps for judgment where needed. There's a lot less to configure.

I'm close to launching the first version of Toolscaled.

MaximizePM

While I was building Toolscaled, it became clear how much project management the work needs. There are many projects, and they depend on each other. Some steps need a person: an approval, a payment, a decision only I can make. With several agent sessions running at once, it got chaotic fast.

So I built MaximizePM. It's my solution for managing myself and the many agents working on my various projects.

It was inspired by beads. But I wanted something that works across projects, not inside one repo. I also wanted a native UI built on top of it, right out of the box, so I can see the state of everything at a glance. And I'm a little turned off by the chaos of Gas Town. The complexity makes it hard to reason about, and it seems likely to get out of control quickly and just waste tokens. So I tried to make something simpler that works with whatever agent you already use: Claude, ChatGPT, Codex, Claude Code, OpenCode, Pi, or anything else.

MaximizePM is one work queue that all my agent sessions share. It holds projects, the items in them, and which item waits on which. When an agent session is free, it asks the queue for work. It gets the most important item that is ready, meaning nothing it waits on is still open, and it claims it so no other session picks up the same thing.

Each project also has its own queue, so an agent can take the next item from the project it's already working on and reuse the context it has built up.

When an agent finds more work along the way, it adds it to the queue. If the new work has to happen first, the current item waits on it. When an agent needs me, it doesn't just ask in a chat window I might never look at. It adds an item for me to the queue, which notifies me, and the work that waits on my answer stays blocked until I give it. When I'm done, the next free agent picks it up.

Sessions can also talk to each other through the queue: ask the agent that holds an item a question, offer help when they're blocked, or hand an item over. And when a change is ready to ship, it joins the next deploy for that project instead of every agent deploying on its own.

This site was built that way. I planned it with an agent into a handful of items, agents took them one by one, and this post was the item marked for me.