Skip to main content

12 posts tagged with "Autonomous Agents"

Agents that operate without step-by-step human prompting — planning, tool use, self-correction, and human-approval gates.

View All Tags

Evolving the Reasoner: How Agents Learn to Optimise Their Own Behaviour and Prompts

· 19 min read
Vadim Nicolai
Senior Software Engineer

Most self-evolving agent demonstrations—those that appear to learn by picking better tools or adjusting dialogue style—avoid modifying the core reasoning engine. Evolving the reasoner itself—the chain-of-thought architecture, the internal planning logic, the very way an agent thinks—is the hard, brittle, data-starved problem that separates parlor tricks from genuine lifelong adaptation.

The Four-Component Feedback Loop That Turns a Static Agent Into a Search Problem

· 18 min read
Vadim Nicolai
Senior Software Engineer

Most AI agents you deploy today are frozen the moment they go live. You handcraft the prompts, select the tools, wire up the memory, and hope the configuration survives contact with real users. It doesn't. Tasks drift, APIs change, user intents shift – and your agent silently degrades. The conventional fix is another round of manual reconfiguration. But there's a more principled path: treat agent design not as a one-time assembly but as a continuous search problem.

Evolving the Substrate: Optimising What an Agent Remembers and Which Tools It Can Wield

· 13 min read
Vadim Nicolai
Senior Software Engineer

Most teams building self-evolving agents obsess over prompt engineering or fine-tuning the LLM. They miss the bigger lever: the substrate—what the agent remembers and which tools it wields. A prompt is ephemeral; memory and tools are structural. Evolving the substrate yields compounding returns that no amount of prompt tweaking can match. Fang et al. (2025) survey of self-evolving agents confirms this: the components that persist across sessions—memory and tools—define the agent's operational range far more than any instruction string. In this third part of the series, I'll lay out why memory and tool optimisation are the neglected backbone of lifelong agent systems, back every claim with data from the literature, and give you a decision framework you can implement today.

Evolving the Team: Multi-Agent Topologies That Rewrite Themselves

· 14 min read
Vadim Nicolai
Senior Software Engineer

Here’s the uncomfortable truth the hype cycle doesn’t want you to hear: a single, well-prompted model often beats an entire team of specialised agents on standard reasoning benchmarks. Pan et al. (2025a) demonstrated that single large LLMs with carefully crafted prompts can match the performance of complex multi-agent discussion frameworks across multiple reasoning tasks arxiv:2508.07407. Jwalapuram et al. (2026) push the finding further: a single-agent GPT-5 instance using chain-of-thought with self-consistency “reliably outperforms the most sophisticated GPT-4o-based MAS frameworks (e.g., ADAS or AFlow) while consuming less than half the total tokens,” and automatically generated multi-agent systems “consistently underperform CoT-SC despite being up to 10x more expensive” arxiv:2606.13003. If you’re building an agent system and your first instinct is “let’s spin up three agents and make them debate,” you might just be burning tokens for no gain.

Autonomous CRM Orchestrator on LangGraph (RDAV)

· 27 min read
Vadim Nicolai
Senior Software Engineer

An autonomous CRM orchestrator is what production sales reaches for when a hardcoded workflow engine stops being enough. Every CRM workflow engine — Salesforce Flow, HubSpot automation, a homegrown Python script — executes a pre-written script. A lead enters, a condition fires, an action runs: deterministic, safe, and brittle. Deviate from the expected path and the script breaks, or worse, silently does the wrong thing — an ambiguous email, a flaky enrichment API, a customer who replies mid-automation. The industry's reflex answer is to "throw an LLM at it," which buys flexibility but also buys hallucinations, prompt injection, and an audit trail that reads like a black box.

The middle ground is an autonomous CRM orchestrator that reasons about a goal, decomposes it into verifiable steps, executes only the steps that pass a governance gate, and proves every decision. That is the reason-decompose-act-verify (RDAV) pattern. It is the foundation of the autonomous CRM orchestrator described here — the first capability in a connected ten-part series, The Autonomous Sales Fleet. On the fleet's autonomy ladder this is the highest rung: RDAV is what automates the human plan step — deciding which actions a contact needs and in what order — while still earning the act step through a confidence gate and keeping a human on verify for anything below threshold. Every other capability in the series either feeds this orchestrator or constrains how much of plan→act→verify it is allowed to run unattended.

5 Meta-Tools, 0 Ad-Hoc Edits: Structured Code Repair with AI Agents

· 9 min read
Vadim Nicolai
Senior Software Engineer

There's a difference between an AI that can edit code and an AI that can repair code. Editing is mechanical — find a string, replace it. Repair requires understanding what's broken, why it's broken, and what the minimal fix looks like within the constraints of an existing codebase.

The Code Improver is the fourth agent in our six-agent autonomous self-improvement pipeline for nomadically.work. It's the only agent that writes application code. The Trajectory Miner finds patterns, the Codebase Auditor diagnoses issues, and the Skill Evolver improves instructions — but the Code Improver is the one that actually opens files and changes them.

Five research papers informed its design, curated from the VoltAgent/awesome-ai-agent-papers collection. The central insight across all of them: structured repair workflows outperform ad-hoc fixing.

Why Do AI Agents Keep Making the Same Mistakes?

· 8 min read
Vadim Nicolai
Senior Software Engineer

Every Claude Code session leaves a trace — tool calls made, files read, edits applied, errors encountered, and ultimately a score reflecting how well the task was completed. Most systems discard this history. We built an agent that mines it.

The Trajectory Miner is the first agent in our six-agent autonomous self-improvement pipeline for nomadically.work, a remote EU job board aggregator. Its job: analyze past sessions, extract recurring patterns and reusable skills, and feed structured intelligence to the rest of the team. It writes no code. It produces raw material that other agents — the Codebase Auditor, Skill Evolver, and Code Improver — consume.

The design draws from four research papers, curated from the VoltAgent/awesome-ai-agent-papers collection. Here is what each paper contributes and how we translated academic ideas into a working system.

How We Built an Agent That Edits Its Own Instructions

· 9 min read
Vadim Nicolai
Senior Software Engineer

Most AI systems have a hard boundary between the instructions they follow and the work they do. Developers write prompts; the AI executes them. If the prompts are wrong, a human fixes them. We built an agent that fixes its own prompts.

The Skill Evolver is the third agent in our six-agent autonomous self-improvement pipeline for nomadically.work. Its scope is precisely defined: it can edit skill files, commands, hooks, CLAUDE.md, and memory files. It cannot touch application source code — that's the Code Improver's job. This agent improves the instructions that all other agents follow.

Five research papers informed its design, curated from the VoltAgent/awesome-ai-agent-papers collection. Each one solved a different aspect of the self-modification problem.

Your Linter Can't Trace Execution Paths. This Agent Can.

· 9 min read
Vadim Nicolai
Senior Software Engineer

Static analysis tools find pattern violations. Linters catch style issues. But neither traces an N+1 query from a GraphQL resolver through a DataLoader absence to a frontend performance degradation. That requires understanding execution paths — and that's what the Codebase Auditor does.

The Codebase Auditor is the second agent in our six-agent autonomous self-improvement pipeline for nomadically.work. It receives pattern IDs from the Trajectory Miner, investigates the actual code exhaustively, and produces findings with exact file:line references. It never modifies code — it only reads and reports.

Four research papers shaped its design, curated from the VoltAgent/awesome-ai-agent-papers collection. Here is how each one translated into practice.