Browse documentation
What is an agent
How Nagent defines an agent as a governed digital worker, when a custom agent is worth building, and how the control plane differs from builder tools.
An agent is a governed digital worker, not a script
On Nagent, an agent is a persistent, accountable unit of work. It has a defined role, a set of skills it is permitted to perform, a knowledge base it draws on, a memory of what it has done, and a trust level that determines how much it is allowed to do without asking.
That last part matters. Most platforms define an agent by what it can do. Nagent defines an agent equally by what it is allowed to do, and how that allowance grows. Every agent on the platform sits somewhere on the L0 to L5 trust ladder, starting as a Novice that proposes actions for approval and earning its way towards autonomy through demonstrated performance. Autonomy is earned, not deployed.
In practical terms, an agent on Nagent is:
- A role, not a prompt. An agent carries a job description, an operating scope, and boundaries, the same way a new hire does.
- Skilled, not general. Agents perform through explicit skills: documented, versioned procedures with guardrails, rollback steps, and escalation rules built in.
- Remembering. Through Agent Smriti, an agent retains context across sessions: decisions made, feedback received, preferences learned.
- Accountable. Every action is logged, reviewable, and attributable. The Karmic Feedback Loop turns outcomes and human feedback into trust adjustments. Reformation Rules define what happens when an agent gets it wrong.
Prebuilt teams cover the common ground, custom agents cover the business
Nagent ships with prebuilt agent teams for marketing, customer experience, sales, and research. For most organisations these are the fastest path to value, and the recommended starting point.
Build a custom agent when the work is specific to the organisation rather than the function:
- The process is proprietary. A pricing approval flow, a compliance checklist, a QA gate that exists nowhere else. Prebuilt agents encode best practice; custom agents encode house practice.
- The knowledge is internal. The agent must reason over internal documents, product catalogues, contract templates, or historical decisions that no general agent has seen.
- The tools are yours. The work runs through internal APIs, legacy systems, or niche software that standard integrations do not cover.
- The accountability is unusual. Some roles need tighter approval loops, unusual escalation paths, or a slower trust progression than the defaults. Custom agents let those rules be set explicitly.
- A prebuilt agent almost fits. The most common case. Clone a prebuilt agent, adjust its skills and boundaries, and deploy the variant. Custom does not have to mean from scratch.
Builder platforms make agents, Nagent runs them
A fair question: with tools like Claude Code and other agent builders available, why build agents here?
The honest answer is that these are different layers of the stack, and Nagent uses some of them internally. Claude Code is an excellent environment for a developer to construct agent logic. What it is not is a place for an enterprise to operate a workforce of agents over time.
The gap shows up after the agent is built:
| Concern | Builder platforms | Nagent Agent Control Plane |
|---|---|---|
| Who can this agent act as, and up to what limit | Set in code, per project | L0 to L5 trust ladder, enforced by the platform |
| What happens when it makes a mistake | Manual investigation | Karmic Feedback Loop and Reformation Rules |
| What does it remember between runs | Rebuilt per session or hand-rolled | Agent Smriti, persistent and tenant scoped |
| Who approved that action | Git history, at best | Task level approvals with a full audit trail |
| How do non-developers work with it | They do not | Shared workspace, chat, tasks, and Live Ops |
| How do agents work together | Custom orchestration code | Teams with leads, hierarchy, and shared knowledge |
Put simply: builder platforms answer "how do I make an agent do X". Nagent answers "how does an organisation trust agents with X, prove they did it correctly, and expand what they are trusted with over time". Teams that already build with Claude Code or similar tools can bring that work onto the platform; the control plane governs agents regardless of where their logic originates.