Rails

ThinkingNovember 2026

Rails, committed

What Rails commits to, and in what order: the best place to build and manage agents, with each agent going where people already work.

Making agents work is the hardest problem in software right now. The models are smart enough to do real jobs. What breaks is everything around them: what the agent remembers, what it's allowed to touch, and the models changing underneath it. On my own setup, the models behind my agents can change several times in a week.

Keeping an agent working is the hard part

Recruiting, my writing and the product itself all run through my own agents. Keeping them working takes more of my attention than building them did.

Rails is a managed agents platform. Managed agents are what Rails runs for a company. Agent management is the job that company's people do every day, and Rails is built for both.

This piece is what I'm committing to, and in what order.

I'm building the best place to build and manage agents

My mission is to build the best place to build and manage agents. Plenty of companies could write that sentence. The difference sits directly under it: the agent goes where people already work.

People already have a home for AI. They pay for Claude, ChatGPT or Grok and open it every morning. They won't leave it for one more app. Rails builds the part that makes an agent good, and carries it into whichever app they use.

OVERSEEN: THE NEW IT DEPARTMENTwhere people meet the agentbuild and oversee hereClaudeChatGPTGrokRails deskSAME AGENTplaybookmemorytoolsits own appthe agent, the part Rails ownsbought, swapped quietlymodelsharnessesdatabasescloud computers

An agent has four parts, and the chat is where it runs

An agent has four parts. There's the playbook it follows, its memory, the tools it can use, and its own app, the pages it pulls up beside the conversation for the work at hand. The chat is where it runs, so I treat the chat as the host more than a part.

Most people building agents stop at the chat. A chat is fine for a question. A job needs a pipeline of candidates, a budget, or a draft waiting for a yes, and those need a screen built for the work. Everyone wants an agent and an interface made for them. Either one alone falls short.

I learned this by running my own. I wanted what I'd been looking at to stay with each agent as I moved between them, so I built a system where every agent gets its own app. Every agent should ship with one. Soon people won't download apps first. They'll get agents that come with an app.

An agent should also cover a whole job, the many things a job title does. An agent that does a single task is a tool.

the chatClaude, ChatGPT, Grok or the Rails deskPlaybookhow the job gets doneMemorywhat it knows about youand the companyToolswhat it's allowed to useIts own appthe screens it pulls upbeside the conversationanother chat: the same agent can move rooms

Rails buys the infrastructure and does its best work above it

An agent business has two layers. The infrastructure layer is the models, harnesses, databases and cloud computers. The playbook layer is how a specific job gets done. Rails buys the first and competes on the second.

Other companies improve the infrastructure every week, so I buy it instead of building it. The tools that run agents are converging, the open source ones are good, and they support the same standards. Most engineers are composition engineers now. The work is picking the right models, vendors and open source tools for each job, stitching them into a workflow that runs in any host, and building the custom software and interface each job needs on top. Composing them well is closer to an art than a science.

What's left to make well is a company's memory, its playbooks and the app each agent carries. Software is easy to copy now. A company's own know-how, turned into the playbooks its agents follow, stays its own.

When a better model ships, every agent on Rails gets better with it, because the playbooks and memory stay put while the model under them improves. Most companies don't want to pick vendors anyway. They want one front door that handles the hosting, the tools and the building.

The agent goes where you already work

This is the part I care about most.

People move between Claude, ChatGPT and Grok all the time, and their work stays behind in whichever app they left. Each lab wants you inside its own app, so none of them will build an agent that follows you to a rival.

Plenty of agent products ask people to come into their app and work there. I don't think that's realistic. People won't leave the AI they already pay for and open every day, so Rails goes to them.

In practice, the agent is its app, packaged to plug into any host. Connect it to Claude, ChatGPT or Grok, and it knows who you are. It brings your playbook, your memory, your tools and the screens it uses for your work. The same agent can run in Claude today and ChatGPT tomorrow, and its jobs can split across hosts at the same time. I can pick up one of my agents, move it somewhere else and rehome its main thread, and it keeps everything it knows.

Portability changes what's worth building. Nobody knows which host people will settle on, and I don't want Rails to bet on one. Once the model and the chat are things you can switch, the playbook worked out for a job is what makes an agent good. Where an agent runs matters much less than its tools, its memory and its app.

It also changes how a company rolls agents out. A company issues its people machines, and each person shapes theirs around how they work. Agents will go the same way, in two layers. The company layer is shared: its memory and its connections to the tools it runs on. The person layer is each person's own workflows. Both layers travel with the agent into whatever app that person prefers.

Moving an agent between hosts can't mean losing sight of it. Wherever an agent runs, you should be able to see where its main thread is and whether its jobs are alive or stuck.

Everyone will have a preferred home, and for most people it will be one of the big labs' apps. Rails can be a home too, the most malleable one, for people who want every layout their own. Some people want a managed default that works out of the box, and others want to shape everything. Both need an agent built from parts that travel.

with a Rails agentwithout RailsClaudecompanypersoncompanypersonplaybook, memorystay behindChatGPTcompanypersoncompanypersontools:set up againGrokcompanypersoncompanypersonits app:gonemain thread, visible: where it runs, alive or stuckwithout Rails: lost track of

People meet the agent through two doors

The first door is the Rails desk. The chat sits beside a desk that holds the screens the agent has pulled up for you. Some of those screens are one-time: the agent puts something on your desk when you need it, and it goes away when the work is done. A fixed tab for every screen would hide that.

The desk handles a three-way interaction a chat box can't. You work with the agent, the agent works with its interface, and you work with that interface directly. The desk is where someone builds agents, shapes them and oversees them, with full control over their apps.

The second door is everywhere else. Most people on a team won't build agents, and they shouldn't have to. They meet the agent inside Claude, ChatGPT or Grok, with its playbook, memory, tools and app intact.

Someone has to run the agents

Once every person has agents, someone has to run them. That person picks the models, grants the tools, watches the costs and swaps in better parts as they ship. The job looks a lot like IT. Good IT swaps the tech underneath while people barely notice, and the whole system gets better. Rails does that for the agents it runs, and I run my own the same way. Each one has a budget that pauses it at the limit, tools it has to be granted, keys it never sees and a record of every call it makes. The longer version is in Agent management is the new IT department.

People deploy now, and the product takes over more of it

Most people won't set up their own agents today. So Rails starts as a service, a fractional managed agents department. It begins with a free consult to find the problems a company most wants solved. Then comes an implementation, which includes building the custom software and interface each job needs. After that, a retainer tied to goals we agree on up front, like time to hire or pipeline, keeps us at the company's side.

We start with go-to-market and recruiting, because their outcomes are the easiest to measure, and with teams that recently raised or expanded and aren't technical.

That work is people heavy, and I'd rather say so plainly. For a while, technical people will set up the workspace for everyone else and show them they can shape their own interface. Self-serve is where it has to go to scale. Over time the platform carries more of the setup, the swaps and the oversight, so each person on the team serves more companies. A deploy company adds people for every customer. I want Rails to be the anti-deploy company, one that gives everyone else the power engineers got from AI.

01free consult02implementationincluding custom softwareand interface03retainer tied to goalslike time to hire or pipelinepeopleplatformsetupswapsoversightnowlatereach person serves more companiesa deploy company: one person per company

I'm customer zero, and Rails is built with Rails. Most days I work with my agents in two shifts, a long one through the working day and a second one late at night, across product, recruiting and writing. It already works on jobs beyond building Rails. My recruiting agent finds candidates and runs the outreach, and I approve every message it sends.

Coding agents closed the engineering gap I had early on and let me build things I couldn't have built alone. Rails is how I give everyone else that same lift in their own work.