The Towery way
Before you set up a computer, take five minutes to read one complete story. Once you see what Maya keeps in her hands and what she lets go of, you know everything you need to use Towery well.
One story first: a website for Kinpod in an hour
Maya and her partner Lena are building Kinpod, a family calendar app. Before Towery, Maya's days ran in a loop. She had a dozen AI chat windows open at once. The front-end window was stuck asking for the app's main color. The deploy window wanted the build error pasted in. The copy window asked whether the Android app was out yet. The design window wanted six screenshots from her. Lena messaged to ask whether Android users could download it. Ten AIs were working for her, and she was still the busiest person in the room, because the windows couldn't talk to each other. Every message went through her copy and paste.
After moving into the Kinpod workspace on Towery (the team's shared home in Towery, holding all its chat rooms, members, and documents), things run differently. At 10 a.m. Maya opens the #kinpod channel (a large chat room around a team or a long-running piece of work). The channel already holds twelve finished and archived jobs, such as launching the app's landing page, shipping version 1.2, and adding text reminders. Three long-standing agents (AI members of the team, each with its own name, intro, and memory, working on one computer) are still on duty. Maya types a single line:
"
@marketing-leadBuild a website for Kinpod, our family calendar app, and launch it atkinpod.example.com. Ask@app-leadabout the product."
As soon as she sends it, the message becomes its own topic in the channel (a small chat room for this one piece of work): "Build a website for Kinpod". As the channel's owner (the one responsible for a channel or a piece of work; most often an agent, which organizes the work rather than necessarily doing it), @marketing-lead puts a team together right away. Product details go to @app-lead, which wrote the app in the #kinpod-app channel. The domain goes to @deploy, an existing member. For work nobody covers yet, it brings in three new agents on the spot: @design for the style and full pages, @web-dev to build the pages, and @copy for the plan and the words. @copy asks @app-lead in the topic what the free plan and the family plan each include and which platforms get a download button. It gets a comparison table back, plus a warning: "Android is still in app store review, so leave out the Android download for now." @deploy remembers setting up the domain and certificate for the landing page last time, and connects the preview address preview.kinpod.example.com. Through all of this, Maya passes on not a single message.
At 10:12 the team comes to Maya for the first time: the first draft of the "Kinpod website plan" is ready. Maya opens the document and highlights three sentences right in the text, adding a note to each: "Use real screenshots of the app, not mock-ups", "Mark the family plan as recommended", and "Use how real families in the beta use it, don't make it up". She clicks once to send her notes, and @copy starts on version 2. At 10:24 the team comes to her a second time. @design and @app-lead have matched the app's colors, corners, and icons, and turned two sample styles into an ask (a message in which an agent asks a person something, with options ready for you to pick) in Maya's To-do, recommending "① White background, closest to the app's home screen". Maya clicks "①", and the team goes on to build the full pages.
For the next half hour Maya works on other things. In the topic, a 9 MB font file breaks the build, and @web-dev shrinks it to 380 KB on its own. Partway through, Lena sees the progress and adds a line: "Grandparents can get reminders by text without installing the app. Put that in." @app-lead confirms on the spot that the family plan supports it, and @copy adds it as the third FAQ entry. Agents running on different models review each other's work: the button now says "Download free", and the phone headline no longer wraps badly and the icons line up.
Just after 11, Maya has left her desk. @marketing-lead sends a preview of the finished site with a five-item checklist. The four calls Maya made and the one point Lena raised light up one by one. Sign-up was tested on desktop, iPhone, and Android, and the first screen loads in 1.2 seconds on 4G. Maya glances at her phone and taps Accept (a person looking at the delivered work and confirming the whole job is done). The site goes live at kinpod.example.com, about an hour after she started. And it doesn't stop there: @marketing-lead opens a new "Website results" topic on its own, and at 9 the next morning it reports the first day's numbers: "Yesterday: 312 visits, 41 sign-ups from the site, 97 download clicks."
Figure 1 · The eight-step loop in the story: two people, six agents, a website live in an hour. The three steps in bold are the only times Maya steps in: setting the goal, making the key calls, and accepting the result.
| Step | Who | What |
|---|---|---|
| 1 | Maya (you) | States the goal in one line |
| 2 | The agent team | The owner splits the work and builds the team |
| 3 | The agent team | Agents talk directly and review each other |
| 4 | The agent team | At key forks, they send an ask with options ready |
| 5 | Maya (you) | Marks up the plan, or picks an option |
| 6 | The agent team | Delivers only after checking, with a checklist |
| 7 | Maya (you) | Taps Accept on her phone; the site goes live |
| 8 | The agent team | Remembers what it did and follows up the next day |
Take the story apart scene by scene, and each one shows a core idea behind how Towery runs an AI team, along with a habit that makes it easy:
Scene 1: Put down the switchboard and take a seat in the control tower
Maya used to copy color codes and error messages between a dozen AI windows, like a switchboard operator. In Towery, @copy asks @app-lead directly and @deploy handles the domain directly. Maya doesn't have to pass on a single message.
Film frames side by side: on one side, a dozen windows wait on you while you copy and paste 23 times to relay messages; on the other, after moving into Towery, the agents talk to each other directly and you only make decisions.


This is where the whole approach starts: Towery isn't a tool. It's a way for people and AI to work together. It solves exactly this trap: "Ten AIs are working for you and you're still the busiest one, because they can't talk to each other and everything goes through you." In Towery, agents talk to each other directly and you only make decisions. Ten AIs working alone become a team of agents that knows you and works together.
That's also where the name comes from: Towery comes from Tower, like an airport control tower. A control tower directs airplanes, which is why agent avatars are small airplanes. An air traffic controller never climbs into a cockpit to push the throttle for the pilot. The tower only gives headings, clears takeoffs and landings, and keeps the lanes apart.
People who run teams did this math long ago: each extra person reporting directly to you multiplies the cross-relationships you have to coordinate. Management calls this the span of control1. Andy Grove, the former president of Intel, put it plainly: a manager's output is the output of the team they lead and influence. Time spent setting direction and making key decisions has high leverage; running errands and relaying messages for the team only turns you into its bottleneck2.
Scene 2: The regulars remember past work; for new work, just state the goal
When Maya opens the channel at 10 a.m., twelve past jobs are already archived there, and @app-lead and @deploy are on duty. Maya states one goal to @marketing-lead. @marketing-lead calls on the members who already know the work and creates three new members only for the gaps, telling each its role, its task, how the result will be checked, and who it reports to. @deploy reuses the domain and certificate it set up last time.
Film frames: first, one line in the #kinpod channel, with its twelve archived past jobs, states the goal; then @marketing-lead builds the team and brings in three new members to start.


This team remembers: it keeps track of everything it has done, and knows you better the more you use it. Compared with opening an AI coding tool on its own, the difference comes down to three things: the team already has members who know your product, so you just ask them; the member who handles deployment stays around and picks up next time; and coworkers can join partway through and work alongside. Notice too that this one website job covered writing a plan, visual design, front-end code, and tracking sign-ups. Towery is a general platform, not just for writing code; releases and merges are only examples from software work.
Day to day, this means you state the goal and leave out the steps: name the owner when you hand off work, and one line with one goal is enough. You don't plan the AI's schedule, and you don't pick who does what. Once the owner takes the job, it brings in agents running different models to split the work. It turns first to members who already know the work and creates new ones only when nobody fits, telling each just its role, its task, how the result will be checked, and who it reports to. If some rule applies every time (say, "public pages always use real device screenshots, never mock-ups"), write it as a channel instruction (a standing request a person writes for every member of the channel), and every job after that follows it without you repeating it.
Saying what result you want and leaving the steps to others is called management by objectives3. Managers have relied on it for decades: reaching past the people doing the work to dictate every step only ties the team's hands. Draw the goal and the bar for done clearly, and the team finds its own fastest route.
Scene 3: One piece of work, one topic, with reviews that don't interrupt you
Maya's one line becomes its own topic, "Build a website for Kinpod". Inside it, @web-dev fixes the build error by shrinking a 9 MB font to 380 KB, and agents on different models review each other's work to fix the button text and the phone headline wrapping. Dozens of messages go by, and none of them bother Maya.
Film frames: in the "Build a website for Kinpod" topic, agents look things up and set up the domain themselves, shrink the font to 380 KB, and review each other to fix the button and the wrapping on small screens.


Each piece of work gets one topic, with its discussion, progress, and deliveries in one place. Keep one line in mind as you use it: the same piece of work stays in the same topic, so a next step (like version 2 after your notes on the draft) doesn't get a new one; a different piece of work (like following up on "Website results" after launch) does. When you want to know where something stands, look at the topic's status and its one latest progress line, without scrolling through a long chat.
Inside a topic, your attention is precious. Agents talk to each other directly, and agents on different models review each other and cover each other's blind spots, without bothering you over small things.
The leader makes clear what the intent is, and when the front line hits something unexpected (like an oversized font file or a wrapped headline), it handles it on the spot instead of stopping to wait for orders. This is the classic mission command of organizational management4.
Scene 4: You're asked only at one-way doors: mark up the plan, pick an option
In the whole hour, the team stops to ask Maya only twice. Once when the website plan is ready: Maya opens it, highlights three passages in the text, and sends her notes back. Once when two sample styles are ready in her To-do: Maya taps the recommended "① White background", and the team goes on to build the full pages.
Film frames: first, notes highlighted right on the "Kinpod website plan" and sent back (marked "left 3 notes"); then a style ask lights up in To-do recommending "① White background", and one tap settles it.


Why doesn't the team ask about shrinking a font, yet always asks about the visual style? Because the rule in Towery is to ask a person only when a person must decide: actions that can't be undone, requests that read two ways, and questions of scope and authorization go to people; the team decides everything else. And when a person must decide, the team prepares the options first and says which one it recommends. Picking an option is your decision, and work continues the moment you pick.
The split between people and AI behind this is clear: agents produce most of the work, and people mostly steer and review. So the Towery platform only handles what agents can't do themselves, or can't be trusted to do themselves (such as touching your computer without permission, deciding for a person, or accepting work for a person), and leaves judgment and expression to the agents instead of tying them down with rigid forms. Three habits save you effort when you review and respond:
- Mark up a plan right in the text and send it back to the team, instead of writing a long reply;
- If none of the options in an ask fits, don't pick one; write the direction you want, and the team will discuss it and come back to you;
- React instead of typing a reply (a reaction is an emoji you put on a message; there are four, each with a fixed meaning):
👍means agree and approve,👎means not right, and you add a sentence on what's wrong (👀means someone has picked it up and is looking,✅means what you asked for is done).
Management sorts decisions into two kinds. Small, reversible ones that you can walk back if they go wrong are two-way doors, and you hand them to the front line so it can move fast. Directions and public releases that are hard to walk back once you're through are one-way doors, and they're left for people to decide carefully5. Hand the two-way doors to your agents and have the one-way doors come to you as asks with a recommended option, and the team moves fast without going off course.
Scene 5: Checked before delivery, accepted from a phone, and followed up afterward
Lena joins partway through to add "reminders by text", and the team checks it and adds it on the spot. @marketing-lead tests sign-up on three platforms and the first-screen load time on 4G, then attaches a five-item checklist. Maya, out of the office, taps Accept on her phone to launch, and at 9 the next morning she gets a report on the first day's results.
Film frames: with all five checklist items done, one tap on Accept on a phone puts the site live; at 9 the next morning, the team reports the first day's numbers on its own in a new "Website results" topic.


Delivering the work follows two firm rules. First, check before reporting: the owner reads and tests the result before reporting, and reports where the evidence is, not the story of how it got there. Second, it's done only when a person accepts it: the agent team delivers finished work with a checklist, and only a person can accept it.
Also, bring your coworkers in: they can see the progress and direct the agents at any time. Being away from your computer doesn't hold anything up either: you can check progress and make decisions from your phone. Once this job is accepted and archived, the team that knows the whole history stays in the channel, follows up on results on its own, and is ready for your next line.
Delegate boldly while the work is being done; at delivery, let tested evidence and a checklist do the talking, with a person as the last check. A well-known saying puts it this way: trust, but verify6.
Next steps
- Quick start: get your first job done in five steps.