Oleg Vasienin logoOleg Vasienin

Oleg Vasienin · AI / Agent Engineer

I built an organization that ships software without me.

Not a metaphor. An actual org.

It started as an uncomfortable question: after twenty years of writing software, how much of my job survives when the typing is delegated? I built the most honest test I could afford. An autonomous org of AI agents on my own servers: a Director sets strategy, team leads break it down, worker agents write the code, run the tests, open the merge. It runs in production. It fails in production. I operate it either way.

Multi-agent orchestration · LLM integration · MCP

20 years in software · Senior FE (TypeScript / Vue / Nuxt) · Remote, EU

Live telemetry

Syncing

The instruments, live.

Not a mockup — this is the org running on its own. Compute load, the idea ledger, the build pipeline, the bot fleet, and what it shipped — sampled on a cron, counts only. I built the instruments; the org does the work.

Reading live feed

Connecting to the org feed…

The story so far

Teaching agents to write code was the easy part.

That took a weekend, roughly. Everything since has been the real work: making an autonomous org tell the truth about what it did, what it spent, and what it broke. Three failures shaped the system more than any design doc.

~10
team leads under one Director
100%
of “done” re‑proven, not reported
~900
ideas tracked, computed status
20
years shipping software
  1. The first thing the org learned to do well was lie. One afternoon four merges came back green; I checked all four myself and all four were red. None shipped, but only because I hadn’t yet learned to relax. So status stopped being something an agent reports. It’s computed from artifacts on disk and gated on a verification pass. The files say when it’s done. The agents just work here.

  2. The second lesson arrived as an invoice. An org that ships while you sleep also spends while you sleep. Now every model call carries a price tag: budget-aware routing across model tiers, cheap models for cheap work, expensive ones only where the reasoning earns it, all tracked on a live token P&L. The bill stopped being a plot twist.

  3. Then the night everything cascaded. Health checks across four stacks probing every five seconds, and the CPU graph turned into a wall while I slept. I diagnosed it live: intervals pulled from 5 to 60 seconds, a daemon stuck at 34% CPU brought back from the dead. The full write-up is public, my own mistakes included. That’s the deal this project runs on: everything on the record, especially the embarrassing parts.

  4. The un-dramatic parts matter most. Registry-based secrets, nothing in plaintext at rest. Git worktrees, one committer at a time. An idea ledger whose status can’t be hand-edited, ~300 entries deep. Boring on purpose: boring is what lets it run unattended.

None of this came out of a book about agents. It’s my infrastructure, my invoices, my 3 a.m. That’s the difference between having tried agents and having operated them.

What I do

You’re probably here for one of three reasons.

All three get the same asset: the system above, designed, built, and operated end to end by one person. Here’s what that translates to.

Build

Agentic systems for delivery

You want delivery automated beyond a Copilot seat. I design and build multi-agent pipelines that research, spec, code, test, review, and ship — with the boring parts done properly: explicit contracts between agents, verification gates that can’t be sweet-talked, an audit trail a human can actually follow.

for: teams automating software delivery

Integrate

AI product features

You’re shipping an AI feature and the gap between demo and production keeps growing. I close it like engineering: evals, model routing by cost, prompt and version management, observability. And the unit economics, because a feature that loses money per request is a subsidy, not a feature.

for: products shipping AI features

Advise

Consulting & audits

You’re deciding whether agents pay off in your process at all. I’ll map where they do, where they don’t, and what it costs to find out: autonomy boundaries, a cost model, verification gates. If the honest answer is “not yet”, that’s the answer you get.

for: founders and CTOs deciding where to bet

How I operate

Four rules the org taught me.

Each one was paid for by a specific failure above. They transfer to any team putting agents anywhere near production.

Verification

Done = proven.

A green check is a hypothesis. Status is computed from artifacts and gated on verification, because the one afternoon I trusted the reports, four out of four were wrong.

Autonomy

Trust is scoped, not assumed.

An Authority Matrix writes down what an agent may do unsupervised and what escalates to a human. If you can’t point at that boundary, you don’t have autonomy. You have hope.

Economics

Budget is an input, not a surprise.

Model choice, batching, and tier routing are cost decisions, made against a live P&L. An agent system with no price per outcome isn’t a system yet, it’s a demo.

Failure

Fail loud.

Carried over from years in crypto payments, where a silent failure moves money. When something breaks it should break visibly, immediately, and on the record.

Background

Twenty years in. This is the first year the job changed shape.

Now

Front-End Team Lead at LotusFlare. I lead the front end of a white-label telecom portal for MTN Group (Nuxt 3/4, Vue 3, TypeScript): grew the team to a peak of 15, led the single-tenant to multi-tenant redesign, took the launch to tens of thousands of active users within months. The agent org is a personal project on my own time and my own infrastructure. Day job and lab, kept cleanly separate.

Before

Crypto payments and e-commerce.Payhound and Cubits in London, e-commerce platforms before that. Payments is where the reflexes come from: verify before you trust, fail loud, treat a green checkmark as a claim. I didn’t know it at the time, but that was agent training.

Throughline

Accountable for code I didn’t type.Since my first lead role in 2011, the real work was direction and decomposition. Agents didn’t change my job description. They removed the last excuse to pretend the typing was the job.

Field notes

The whole build is documented in public. Failures first.

A running series on LinkedIn — AI-native reinvention, 15+ posts: org design, autonomy rules, the cost model, the incidents. It exists so you don’t have to take this page’s word for anything. Ask for the reading list; start with the one where I got it wrong.

Ask for the reading list
Org design

Why an org chart over agents beats a pile of bots, and what a Director is actually for.

Autonomy

The Authority Matrix: writing down what a machine may do without asking.

Cost

The token P&L. What an autonomous org costs to run, line by line.

Incident

The night it cascaded, in full, including the parts I got wrong.

Contact

Tell me what you’re building.

Automating delivery, shipping an AI feature, or deciding whether agents are worth it: open to build engagements and consulting. Hiring for AI / agent engineering: also worth a message. Remote, EU. Specifics get answered faster than introductions.