- Entry date
- 20 May 2025
- Category
- Agents
- Lead over the world
- ~1–2 years ahead
- Access
- 🔓 Public
An agent that hits a task it can't do usually fails. Ours wrote the skill it was missing and carried on — and every part of the platform, down to the gateway, was itself an agent.
- v1→v3
- SelfGrow iterations, CLI to live dashboard
- 5-part
- standard agent contract (blueprint/code/settings/types/GUI)
- 13 in 48h
- network architecture versions, AI-paced
Honest evaluation
The five-part agent contract fully proved out and became foundational; self-growth (agents writing their own missing skills) proved real but bounded — reliable for small increments, not for architectural pivots.
What would prove or disprove it further
What would extend the self-growth claim toward fully proven: an agent-generated skill that triggers, unprompted, a restructuring of its own architecture that a human later validates as correct — the thing the report says didn't happen. Short of that, "self-growth works for increments" is as far as the evidence goes.
The evidence — full reasoning behind the verdict
Verdict: partly-proven. Two separate claims are bundled in this report, and they landed differently. The five-part agent contract (blueprint, code, settings, types, GUI) is the clean proven half: it made agents composable and swappable, and the report states plainly that it "survived everything and became foundational" — later work, including the production Director → Manager → Worker → Tool hierarchy, is built on it. The self-growth claim — agents that write their own missing skills instead of failing — is the partial half: it worked, but only within a bounded scope.
The mechanism is stated honestly rather than glossed over: self-growth is reliable for incremental skill gaps, where the agent needs one new tool and writes it. It has no answer for architectural pivots — deciding the system should be restructured is still a human call, not something SelfGrow ever did on its own. The thirteen-versions-in-48-hours pace is real evidence of fast, AI-assisted exploration, but the report is equally honest that this speed produced maintenance debris rather than a free lunch.
The conceptual breakthrough of 2025 was small to state and large to build: make every component an agent, give agents a standard shape, and let them write the tools they don't have. Most of what vocabotics is grew out of that sentence.
What it was
Two ideas, developed together:
- The agent contract. Instead of ad-hoc scripts, every agent had the same
five-part structure — a
blueprint.json, the code,settings.json,types.ts, and agui.tsx. Standardising the shape made agents composable and replaceable: you could swap one for another, generate new ones on demand, and reason about the whole system uniformly. - Self-growth. An agent that meets a task outside its abilities normally fails. SelfGrow instead had the agent create the missing skill on the fly and continue — learning by extending itself rather than stopping.
What we built
- SelfGrow v1 → v3: three iterations, from a CLI to a real-time Socket.IO web dashboard that visualised skills as the agent acquired them.
- vocabotics Agents: the platform that made the five-part contract concrete, with a CLI, tab-completion, and dynamic agent generation.
- vocabotics Network v1 → v13: thirteen architectural versions in two days, each testing a different boundary — agent registry, identity, networking, even an LLM-based proof-of-work experiment.
- Aigen / Grow: pushed "everything is an agent" to its logical extreme — the API gateway and the marketplace were also agents.
The measured signal here is less a single number than a rate: thirteen coherent architectural iterations in forty-eight hours is a pace that is simply not available without AI-assisted development, and it let us explore the agent design space empirically instead of on paper.
What we learned — including the honest negatives
- Self-growth has a ceiling. It works well for incremental skills — the agent needs a small new tool and writes it. It struggles with architectural pivots: deciding to restructure the whole system is still a human judgement call. An agent can grow a limb; it can't yet decide it should have been a different animal.
- "Everything is an agent" is not free. Making the gateway an agent, and the marketplace an agent, is elegant — and sometimes it is just indirection where a plain function would have been clearer and faster. The abstraction earns its keep in some places and taxes you in others, and knowing which is the skill.
- Fast iteration leaves debris. Thirteen versions in two days is a superpower for exploration and a liability for maintenance — you end up with near-duplicates that later have to be pruned.
Where it went / status
The agent contract survived everything and became foundational. The self-growth idea matured into the lab's later work on a governed fleet, and the Director → Manager → Worker → Tool hierarchy (a separate, protected report) is the production form of it. This was the year "everything is an agent" stopped being a slogan and started being an architecture.
What is still open — kept visible
The honest edges, next to the wins. This is what turns 🔬 into 🟢 — honestly.
- Self-growth is reliable for incremental skills; it struggles with architectural pivots, which still need human judgement.
- 'Everything is an agent' adds indirection where a plain function would do — the abstraction helps in some places and taxes you in others.
- Rapid iteration (13 versions in 48 hours) explores the space fast but leaves a trail of near-duplicates that later have to be culled.
Where this connects
Sources
- vocabotics project audit — SelfGrow v1–v3, vocabotics Agents, Network v1–v13, Grow (2025)vocabotics internal project history · as of May–June 2025