Our AI Learns to
Build What It's Missing.
NvAgent notices the capability gaps inside real conversations, suggests the sub-agents, skills, MCP services and integrations that would close them, builds them from plain-English AI wizards, tests them for real, and hot-reloads them into a running system — with no restart, and nothing going live without an audited approval.
The Agent Detects. Humans Decide.
The Wizard Builds.
An agent is only as capable as the tools you configured for it. This release closes that loop: NvAgent watches where it falls short, proposes the capability that would have solved it, and gives an admin a one-click path from “the AI noticed a gap” to “the new capability is live in production.”
A live chat turn no sub-agent covers, or a tool no server provides. Recorded asynchronously — the conversation never waits.
The gap lands in a ranked, de-duplicated queue with the evidence: the chat that triggered it, the score, the missing tools.
An AI wizard turns plain English into a real sub-agent, skill, MCP service or integration — drafted, checked, and self-reviewed.
Every draft runs for real in a safe test area before a human ever sees an Approve button. Pass or fail is on the screen.
Approval activates a new version and broadcasts it to every running pod. The next turn uses the new capability. No restart.
It Notices the Gap
While You're Talking.
When the planner scores every specialist against your request and nothing clears the bar — or a step needs a tool no registered service provides — NvAgent doesn't silently degrade. It finishes your turn with the best resources it has, and records the gap on the side.
- Runs inside the planning phase — no extra model call, no added latency
- Captures the evidence: the plan, the task, the best match score, the missing tools
- The assistant can say so: “I've suggested adding a Jira integration to your admin.”
- Only genuine gaps enqueue — the agent never mints resources on a whim
Every Gap, Ranked and Evidenced
Detected gaps are grouped by the conversation that produced them, merged when they repeat, and counted. One-off needs stay quiet; recurring gaps rise to the top with proof attached — so the decision to build is evidence-based, not a guess.
De-duplicated & counted
Similar gaps merge into one row with a frequency counter and a last-seen timestamp. Ten conversations hitting the same wall become one high-priority decision.
Dismissal memory
Say no once, with a reason, and the agent stops re-asking. Suppressed classes of suggestion never clutter the queue again.
Traceable to the chat
Every suggestion carries the session id and the original request — which becomes the build description when an admin says go.
Describe It in Plain English.
The Wizard Decides What to Build.
Type one request — even a big one — and the master wizard decomposes it into a build plan across all four resource types, in dependency order: access first, then procedure, then the worker that uses both.
Four Kinds of New Capability
A Skill is how. A Sub-agent is who. An MCP service is what it may touch. An Extension changes how the loop itself works. Each has its own creator, its own checks, and its own risk gate.
Repeatable know-how
A reusable multi-step procedure or domain knowledge, written as instructions the engine already interprets. Inert — no code executes — and shareable across every agent.
Low riskA new specialist
A distinct role the orchestrator can plan around: its own model, its own scoped toolset, its own skills, its own output contract — fully declarative, so the DAG monitor keeps working unchanged.
Medium riskNew system access
A typed tool bridge to an external system — Jira, Confluence, your private API. Scaffolded from a vetted template with minimal scopes and an exact egress list. Never freeform code.
High risk · always gatedNew runtime behavior
The last resort: behavior that must hook the loop itself — intercept a tool call, react to a lifecycle event, schedule recurring work. Admin-initiated only, and sandbox-only forever.
High risk · sandbox only
The Build Logic Is Itself a Skill
Instead of hard-coding “how to create things” in Python, NvAgent puts the creation knowledge — the interview questions, the writing guide, the templates, the validators, the test loop — into four creator skills. Which means the build logic is versioned, hot-reloadable, and improvable through the same governance it feeds.
skill-creator
Interviews, drafts the instructions, validates the structure, tunes the description so the skill triggers accurately, then eval-tests it.
subagent-creator
Six stages: role analysis → tool mapping against the live catalog → skill selection → templated system prompt → model & limits → self-review.
mcp-creator
Integration analysis → reuse check → typed tool design → minimal scopes & exact egress → scaffold from a vetted template → smoke test.
extension-creator
Starts by trying not to build one: if a skill, sub-agent or MCP service can express it, it routes there instead. Otherwise: narrow hooks, declared permissions, sandbox run.
Prefer generating declarative artifacts the existing engine already interprets. Gate anything that executes code behind validation, sandboxing, and a human approval decision. Self-extension without governance is indistinguishable from uncontrolled self-modification.
Nothing Ships on a Promise
Every new creation runs for real before anyone can approve it. A generated sub-agent is spawned once on the example task and scored by the evaluator. A generated MCP service is booted in the sandbox and every tool is called. A generated skill is trigger-tested and eval-run. The reviewer sees the artifact, the checks, and a live ▶ Test result in the same dialog.
New Capabilities Go Live
While It's Running.
Previously, a new skill or specialist meant a deployment. Now, approval writes a new active version, materializes it to every pod, and atomically swaps the in-memory registries. The next turn — in the same conversation — can use the capability that didn't exist a minute ago.
- Atomic swap of skills, sub-agents and the MCP tool catalog — never a partial state
- A file-hash guard skips no-op reloads and logs exactly what changed
- Cross-pod broadcast over the existing event channel — no new infrastructure
- The database is the source of truth; every pod re-materializes from it
- Roll back to the previous version, or turn a resource off, without losing its history
The Audit Grades Everything It Built
Creating capabilities is only half of it. NvAgent measures how well each one actually performs — activations, error rate, runtime, cost, and an evaluator score — and marks it Healthy, Review, or Failing. When a resource degrades, an admin invokes the wizard on that very resource to analyze it and propose an improved version.
Effectiveness, not just uptime
Evaluator scores join execution telemetry, so “it ran” and “it worked” are different columns. A skill with a 0.44 eval score is Failing even at 0% errors.
Wizard-assisted improvement
A degrading resource shows its top issue. One click hands it back to its creator skill, which analyzes the failures and drafts a v-next — which then queues for approval like anything else.
Append-only audit trail
Every generate, validate, approve, reject, reload, rollback and disable is written to an append-only log with the actor, the artifact, the result and the reason. Exportable.
Self-Extending, Not Self-Modifying
Chat users never author. Chat only triggers detection. Every build and every edit — including an admin's own — queues for approval before it reaches production. There is no fast path.
| Guardrail | What it enforces |
|---|---|
| Role-based access | Identity plus permissions on every mutating endpoint. The admin console is invisible to chat users. |
| Schema validation | Strict structure checks, size caps, and rejection of duplicates and conflicts before anything is written. |
| Tool & model allowlists | A generated sub-agent may only reference tools that map to registered services and a model that exists in the routing table. |
| Egress scoping | A generated MCP service declares the exact hosts it may contact. Wildcards are rejected; the list is reviewable intent on the approval screen. |
| Sandboxed execution | Generated and third-party code runs only in the isolated executor — never in the API process. Violations are blocked and logged. |
| Approval gate | Every validated build and edit lands in the pending queue. Approval writes a new active version; rejection records a reason. |
| Versioning & rollback | Each activation supersedes the prior version rather than overwriting it — so undo is a first-class action. |
One Gap, Five Lanes, Zero Restarts
From a chat turn the agent couldn't cover, to a live capability every pod is running — the whole journey, with a human decision in the middle and an audit entry at every step.
An AI That Gets
Better at Your Work
NvAgent turns every conversation into evidence about what your platform is missing — and gives you a governed, one-click path to close the gap. Own it, run it, audit it.