Our PracticeTeamPricingConsultingInvestorsGet Started
← All Field Notes
October 31, 2026 Β· by Ravfield-notesai-agentsarchitecturetelegram

The Site Is a Coworker Now

Every website and app we run now has its own agent: its own code, its own personality file, and its own Telegram bot. I can talk to the product from my phone, and talk to JARVIS through the product to change the product itself, without cutting off the branch I'm standing on.

I've been making the businesses themselves smart.

That's the plainest way I can put it. Instead of a website that sits there until someone edits it, the site or app itself is closer to an agent. Lately I think it's closer to a swarm.

A brochure waits. This thing answers.

A normal website is a brochure. Someone writes it, it goes up, it waits. When something needs to change, a person opens a tool and changes it.

What we've been building is different in one specific way: the product knows what it is, and it can act on that. It holds its own code. It knows its mission and vision, because that's written down somewhere it can read. And it can be talked to.

I don't mean a chat widget bolted onto a contact page. I mean the site itself is the thing I'm talking to.

Each product is an Epic, and each Epic owns its own code

Internally I call them Epics. An Epic is one product: a site, an app, a tool. It owns its code, and it owns the rules that govern how that code gets changed.

Two pieces of the Epic are worth naming.

The mission and vision statement is the personality file. It isn't decoration on an About page. It's the document that tells the agent what this product is for, who it serves, and what it should refuse to become. When I need the product to behave differently, that's one of the places I change.

The rules, styles and automations all live inside the site's split architecture: an agentic backend and a customer-facing front end. The front end is what customers see. The backend is where the thinking and the changes happen. Those are separate on purpose, and the reason gets its own section below.

There isn't one model under the hood

If you've only seen agents as a chat window, it's easy to assume there's a single LLM behind all of it. There isn't.

Local inferencing handles automations, the routine work that has to happen constantly and doesn't need to leave our hardware. Batch API calls handle batch jobs, the kind where you send a pile of work and collect it later. OpenRouter calls handle the client- and app-facing conversations, where quality matters and the volume is unpredictable.

Then there are pipeline clusters and workflow banks: the arrangements that decide what happens in what order, and what gets reused instead of rebuilt. That's the part that turns a model into something that finishes work.

Different jobs, different engines, one product.

The split is why I can edit the thing I'm standing on

Here's the part that took the longest to get right, and the part I'd point at if you asked what's actually different.

I can talk to JARVIS through the product to edit and work on the product itself, without cutting off the branch I'm standing on.

Read that literally. I'm using the website. I ask it to change the website. If the change requires the thing I'm using to restart or rebuild, I lose my connection to the request. If something then goes wrong, I lose my ability to fix it. That's a bad place to be, and it's the normal place to be when a system edits itself.

The agentic backend and the customer-facing front end being separate is what prevents it. The part doing the work is not the part I'm standing on. The product keeps serving while the work happens behind it.

We ran into the same problem in We Rewrote the App While Twenty People Were Using It. People were in the middle of a discussion tool while we revised it. The useful outcome wasn't that nothing broke. It was that the work could continue while the tool kept running, and the twenty sign-ins survived.

Every product has its own Telegram bot

Each site has its own Telegram bot. That's the interface, and it's deliberately boring. Telegram is already on my phone, it already works with one hand, and it doesn't require a laptop or a dashboard.

So there are two conversations available from the same place.

I can talk to the product. Ask it what it's doing, what broke, what it needs. That's the coworker conversation.

And I can talk to JARVIS through the product to edit and work on the product itself. That's the builder conversation.

Same bot, same thread, two modes. I'm not opening a terminal to do the second one and a chat window to do the first.

It's all still JARVIS underneath

None of this is a new assistant per site. It's JARVIS, and JARVIS is multi-headed: different interfaces and workers belonging to one coordinated system.

When I talk to the part of JARVIS that works on the TLCAILab website, I'm talking to the same underlying system that runs Anya, our Telegram-based life-management bot and Mini App. Different surface, different job, shared context.

That's a design choice. I don't want a new personality claiming authority over every server. The last thing I need is another character to manage. Vic and Anya have their roles. Every background process doesn't need to become somebody.

(Also, I'm not naming anything Alice or Loki.)

What changes when the product is a coworker

The honest answer is that my job shifts.

A brochure needs a writer and a deploy. A coworker needs a briefing, a review, and occasionally a correction. Most of my time with these products is now the second kind of work: telling it what we're trying to do, checking what it did, and telling it when it got the wrong idea.

It also means the product can explain itself. When something looks wrong on the TLCAILab site, I don't have to go find out. I ask the site. That sounds small. It removes a whole category of 'where do I even start' from my day.

What it doesn't do

I want to be specific about the limits, because 'the website is an agent' sounds like more than it is.

It still needs review. Anything customer-facing gets looked at before it goes out, most of the time. Things we've done a hundred times stop needing a babysitter. New things don't.

It still runs on infrastructure we own and maintain. That's the trade for control. The immune-system Field Note covers one part of what that maintenance actually looks like.

And it's still built around us. You can't download this and inherit our workflows. What we can do is build a tailored version around someone else's business, starting from what they actually need help with.

The part I keep coming back to

I started by making a website that could be edited from a chat. Now the website is the thing I'm talking to, and it's the thing doing the editing.

The site, app, product itself is a coworker now, not a brochure. I didn't plan to describe it that way. It's just what it turned into once the product had its own code, its own mission, and a way to be reached.