Free Intensive Nov 21–22Free 2-day hands-on Vibecoding Intensive on Nov 21–22 at 16:00 MSK (Sat–Sun) · Live Cohort 3 starts Nov 23Join Free →Cohort 3 (Nov 23)
ReleaseAPI / Product · ActionableHabr: MTS AI→ original

MTS AI Built a Virtual Team That Builds AI Agents From a Text Description

MTS AI has taken its contest prototype to product: AI Force, a feature in the MWS AI Agents Platform, builds a bot from a plain-text description. The user says what they need, and an LLM designs the architecture and produces a nearly finished agent. To keep it from springing surprises mid-task, the team surrounded the model with tools, knowledge, rules and blocks. The takeaway for teams: the reliability of an enterprise agent comes from the scaffolding around it, not from a single strong model.

AI-processed from Habr: MTS AI; edited by Hamidun News
MTS AI Built a Virtual Team That Builds AI Agents From a Text Description
Source: Habr: MTS AI. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceHabr: MTS AI ↗
Editor-in-Chief
Key metric #1MCP tools are concrete calls to the platform's API
Key metric #2PreToolUse/PostToolUse hooks physically block dangerous actions
Key metric #3FINDINGS.md accumulates patterns from the agent's real work

Building a demo agent that impresses a jury can take a couple of weeks. Building an agent that an enterprise client will trust with a real workflow is much harder: it has to work reliably every time, not only on lucky examples, and it must not do anything unexpected in the middle of a task. This is the problem the MTS AI team faced after its Meta Agent prototype won first place at an internal contest. In the second part of a long-form post on Habr, the author describes what that prototype became: the AI Force feature inside the MWS AI Agents Platform.

What AI Force does

The idea is simple. The user describes in plain language the bot they need, and a system built on a large language model acts like a virtual development team. It handles the routine engineering cycle: it analyzes requirements, designs the architecture, assembles the agent's configuration, and outputs the result in a form the platform can run. The prototype produced JSON; the product produces an agent that is "ready, well, almost." The authors are explicit about the "almost": a human still reviews the result.

For anyone who has worked with low-code platforms, the point is clear. There, a barrier stands between an idea and a working solution: you have to learn the interface, the blocks, the settings. AI Force lowers that threshold, and the platform becomes a kind of vibe coding for agents: describe the task, get a draft, adjust it.

The shop-floor master metaphor

To explain how the system works, the author compares it to a master craftsman in a workshop. The master has machines and a workbench, tools, knowledge of the material, step-by-step instructions for typical operations, safety rules, physical interlocks, and a logbook where he records lessons. Each element of the system corresponds to a piece of code:

  • LLM makes the decisions, like the master's head.
  • MCP (the tool connection protocol) and MCP tools are concrete calls to the platform's API: create a node, configure a connection, validate the configuration.
  • Skills (SKILL.md) are structured knowledge about the platform, that is, how to read the "blueprint."
  • Workflows / Recipes are step-by-step scenarios: first marking, then drilling, then assembly.
  • Rules are guidelines the agent keeps in context at all times.
  • Hooks (PreToolUse / PostToolUse) are infrastructure blocks that fire before and after a tool call.
  • Findings (FINDINGS.md) is a database of patterns accumulated through real work.

Why blocks matter more than requests

The most practical idea in this scheme concerns hooks. A rule in a prompt is a request: "be careful." The model may ignore it, especially in a long dialogue. A hook works like a guard on a machine: if the condition isn't met, the tool call simply doesn't go through. This is not a request but a structural constraint. For production, that difference is decisive: behavior that cannot be violated in code is more reliable than behavior the model is supposed to "remember."

The second useful detail is the FINDINGS.md file. The agent and developers record patterns from real runs there: what broke, which sequence of actions worked. It is a cheap form of "learning" without retraining the model: the knowledge lives in files, gets loaded when needed, and is edited with ordinary tools.

Takeaways

For those building their own agents, this story points to three conclusions. First, store domain knowledge (Skills) and step-by-step recipes separately from the model: they are easy to update and verify. Second, move everything that must not be violated out of the prompt and into hooks before and after tool calls. Third, keep a log of patterns from real operation and connect it to the agent.

There are limitations too. The published part contains no numbers: how many tokens it takes to assemble one agent, what share of assemblies succeed without edits, what a single run costs. The economics of the solution cannot be assessed from this text, so the continuation is worth waiting for. In addition, this is a description of MTS's internal platform: the toolset is tied to its API, and the scheme can only be transferred as an architectural approach. But the approach itself, with an LLM, MCP tools, skills, recipes, rules, hooks and a findings log, already looks like a working template for any team building agents for sale rather than for a contest.

Story

Key Questions Answered

What AI Force does?

The idea is simple. The user describes in plain language the bot they need, and a system built on a large language model acts like a virtual development team. It handles the routine engineering cycle: it analyzes requirements, designs the architecture, assembles the agent's configuration, and outputs the result in a form the platform can run. The prototype produced JSON; the product produces an agent that is "ready, well, almost." The authors are explicit about the "almost": a human still reviews the result.

What are the key details on The shop-floor master metaphor?

To explain how the system works, the author compares it to a master craftsman in a workshop. The master has machines and a workbench, tools, knowledge of the material, step-by-step instructions for typical operations, safety rules, physical interlocks, and a logbook where he records lessons. Each element of the system corresponds to a piece of code: LLM makes the decisions, like the master's head.

Why blocks matter more than requests?

The most practical idea in this scheme concerns hooks. A rule in a prompt is a request: "be careful." The model may ignore it, especially in a long dialogue. A hook works like a guard on a machine: if the condition isn't met, the tool call simply doesn't go through. This is not a request but a structural constraint.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Hands-On AI Engineering · Hamidun Academy

Build & Ship Production AI Agents Without Boilerplate Code

Start your free 72-hour trial at Hamidun Academy (academy.hamidun.com) — interactive lessons on Claude Code & Cursor, live Tech Radar, and production agent templates.

Start 72h Free Trial →Vibe-Coding Intensive
What do you think?
Loading comments…