The 5 most underrated capabilities in Avery NXR

We have 59 capabilities across 14 categories in Avery NXR. Some get used heavily in every customer install. Others are powerful but underused — capabilities most users don't discover until months in.

This is a tour of the 5 capabilities we think are most underrated. If you've been using Avery NXR for a while and haven't explored these, this post is for you.

Underrated capability 1: Sub-agents

What it is: Agents can call other agents as sub-routines. The calling agent passes inputs, the sub-agent runs, returns output, calling agent continues.

Why it's powerful: Complex workflows decompose into simpler pieces. Instead of one giant agent that does everything (and is hard to debug), you have a coordinator agent + specialist sub-agents. Each piece is small and reviewable.

Example use case: A "respond to inbound lead" workflow could be one giant agent. Or it could be: → Coordinator agent → Sub-agent: research the company → Sub-agent: score the lead → Sub-agent: draft a personalized response → Coordinator pulls outputs from each sub-agent, composes final response

The sub-agent version is more maintainable. Each piece is testable independently.

Why it's underrated: Users build their first few agents as monoliths. They don't reach for sub-agents until they have a complex workflow that's painful to maintain as a single agent. By then, refactoring is more work than starting with sub-agents would have been.

Recommendation: When designing your 3rd+ agent, ask "could this be decomposed?" If yes, build it as a coordinator + sub-agents from the start.

Underrated capability 2: Conditional branching with confidence thresholds

What it is: Agents can branch based on confidence levels of their own outputs. If the LLM is confident, take action A. If low confidence, escalate to human review (action B). If medium confidence, ask another agent for a second opinion (action C).

Why it's powerful: Most agent failures come from acting confidently on uncertain outputs. Confidence-aware branching surfaces uncertainty as a design choice, not a hidden risk.

Example use case: A support triage agent. → High confidence + FAQ-matched → auto-respond → Medium confidence → draft for human review → Low confidence → escalate to human + flag the uncertainty

Three behaviors from one agent based on what the agent knows about its own certainty.

Why it's underrated: Most users build agents that produce confident outputs without surfacing internal confidence. The capability exists but isn't part of the default mental model of "configure an agent."

Recommendation: When building agents that take action (not just draft), add confidence thresholds. The pattern becomes muscle memory after the first 1-2 agents.

Underrated capability 3: Knowledge base retrieval with semantic search

What it is: Avery NXR has built-in vector database integration for semantic search across your documents. Drop in PDFs, markdown, text files, web URLs — the system creates embeddings and makes them retrievable by semantic similarity.

Agents can query this knowledge base as part of their workflow: "find documents relevant to this question, then use them in the response."

Why it's powerful: Most operational agents benefit from grounding in YOUR specific knowledge. Generic LLMs hallucinate. KB-grounded LLMs draw on your actual documents.

Example use case: A support agent grounded in your help docs. → Customer asks question → Agent searches KB for relevant docs (semantic) → Agent drafts response using retrieved content → Response includes citations to the source docs

This grounds outputs in YOUR product's actual documentation, not the model's general training data.

Why it's underrated: Many users assume RAG (retrieval-augmented generation) requires custom infrastructure. They don't realize Avery NXR has it built in. They build agents without grounding when they could be grounding cheaply.

Recommendation: If your agent ever needs to "know" something about YOUR specific business, set up a knowledge base for it. Takes 15-30 min. Quality improvement is dramatic.

Underrated capability 4: Shell command execution with guardrails

What it is: Agents can execute shell commands on the local machine (or deployed environment). With guardrails — explicit allowlist of commands, sandboxed execution, audit logging.

Why it's powerful: Some workflows require interacting with the operating system. Run a backup script. Check disk space. Restart a service. Process files in a directory.

These workflows can't be done through APIs alone. Shell access opens them up.

Example use case: A server health agent (Liam template). → Checks disk space via shell command → Identifies issues via parsed output → Auto-remediates known issues (e.g., clears cache, restarts service) → Pings human via Slack when something needs attention

Half of Liam's value comes from being able to run shell commands. Without that, it's just a monitoring agent. With it, it's a system administrator agent.

Why it's underrated: Shell access feels scary. Users default to "agent can only do safe things." But with guardrails (allowlist, sandbox, audit), shell access is safer than the same commands run by humans (who skip the audit step).

Recommendation: If you have system-level workflows, don't shy away from shell capability. Configure the guardrails carefully. The capability unlocks real value.

Underrated capability 5: Agent-to-agent triggers

What it is: One agent can trigger another agent by emitting a structured signal. The receiving agent runs in response.

This is different from sub-agents (synchronous calls). Agent-to-agent triggers are asynchronous — one agent fires another, doesn't wait for response, continues its own work.

Why it's powerful: Workflows that have decoupled steps that don't need to happen in sequence. The first agent handles its part. The second agent handles its part when triggered. They don't have to wait for each other.

Example use case: A multi-agent customer onboarding workflow. → New customer signs up → Onboarding agent triggers (immediately) → Welcome email agent triggers (next day) → Check-in agent triggers (week 1) → Feedback agent triggers (week 4)

Each agent does its job independently. The triggers chain across time without any one agent waiting on another.

Why it's underrated: Most users build single-agent workflows. The mental model of "agents communicate with each other across time" is less common but unlocks workflows that single agents can't handle well.

Recommendation: When you have a workflow that spans time (days, weeks, months), think about agent-to-agent triggers as the way to chain across the time gaps.

The pattern

Each of these 5 capabilities shares a property: they're discoverable through documentation but not through the visual builder's default flow.

When you build a new agent, the visual builder doesn't say "have you considered using a sub-agent here?" or "should this branch on confidence?" The capabilities exist, but discovering them requires reading docs or experimenting.

This is intentional. We don't want to overwhelm new users with options. We want them to build successful first agents using basic capabilities, then graduate to advanced patterns as they get comfortable.

The trade-off: users who don't read docs or experiment miss capabilities that would improve their agents significantly.

What we're doing about this

We've started:

→ Surfacing these capabilities in monthly "did you know" emails to active users → Adding "advanced" sections to template descriptions showing how each capability could enhance the template → Building example agents in our docs that use each capability → Showing capability usage statistics so users can see what's used vs. underused

The goal: make sure users who'd benefit from these capabilities discover them, without overwhelming new users.

What to do today

If you're an Avery NXR user and haven't explored these 5 capabilities:

→ Sub-agents: Look at your most complex agent. Could it decompose into a coordinator + 2-3 sub-agents? Refactor and see if it's more maintainable.

→ Confidence branching: Look at any agent that takes action (not just drafts). Add a confidence-based escalation path. Notice how much smoother edge cases get handled.

→ Knowledge base: Pick an agent that produces drafted content (emails, responses, summaries). Set up a knowledge base for it. Drop in 10-20 relevant docs. Watch output quality improve.

→ Shell access: Think about any system-level work your team does manually. Could an agent absorb it? Configure guardrails carefully and try.

→ Agent-to-agent triggers: Look at any multi-step workflow that spans time. Could it be chained agents instead of one big agent with delays? Refactor.

Each of these takes 30-60 minutes to experiment with. The payoff is significant.

The broader principle

Platforms often have power-user capabilities that don't get used by typical users. The capabilities aren't hidden — they're documented — but they aren't discoverable through normal workflow.

Power users find them. New users miss them.

For Avery NXR specifically, the 5 capabilities above are the ones we'd most encourage users to discover. If you're at month 2+ of using Avery NXR and haven't tried these, you're leaving capability on the table.

→ avery.software — Free Desktop tier. The capabilities are there. Find the ones that change what your agents can do.