Skip to main content
AI // LLM agents

Agents that do the work, and ask before doing anything scary.

LLM agents can read context, decide on a next step, and call tools: create a quote, look up stock, draft a reply. We build them with tight permissions, logs, and approval gates.

inference.tracelive

{

"summary"
: "Small tool set, strict permissions, full audit trail, human approval for irreversible actions.",
"tools"
: "Your APIs & ERP actions",
"guardrails"
: "Allow-lists · approvals",
"visibility"
: "Traced every step",
"reviewed_by"
: "a human"

}

Good first agent jobs

Support triage

Classify tickets, pull order context, draft replies for an agent to approve.

Quote preparation

Read an RFQ email, find products and prices, draft the quote in the ERP.

Research assistant

Gather facts across internal systems and summarize with citations.

Back-office chores

Chase missing documents, reconcile small mismatches, update records.

Risk levels for agent actions

Action typeExampleControl
ReadLook up an order statusAllowed with scoped credentials
DraftPrepare a quote or emailSaved as draft for review
WriteUpdate a delivery dateAllowed for low-risk fields, logged
IrreversibleSend payment, delete recordsHuman approval required
An agent with access to everything is just an intern with root. Give it a badge, not the master key.
Anvexis Stack AI guideline

What an agent actually is

An LLM agent is a loop: the model reads a goal and some context, decides on a next step, calls a tool such as a search, an API, or an ERP action, looks at the result, and decides again until the job is done or it needs help. The model supplies judgment; the tools supply the ability to act.

That combination is powerful and risky in equal measure. A model that can call tools can also call the wrong one, misread an instruction hidden in an email, or loop on a task it cannot finish. Production agents need the same engineering discipline as any system with write access to business data: least privilege, validation, limits, and logs.

We build agents for specific, bounded jobs where the steps are clear and the value is measurable. A narrow agent that reliably prepares quotes is worth far more than a general assistant that sometimes does everything.

How we design an agent

  1. Step 01

    Define the job

    Write down the task, the inputs, the expected output, and what 'done' means, as you would for a new hire.

  2. Step 02

    Choose the tools

    Expose the smallest set of tools that can do the job, each with typed arguments and validation.

  3. Step 03

    Set permissions

    Give the agent its own scoped credentials, and decide which actions need human approval.

  4. Step 04

    Build the evaluation set

    Collect real examples with expected outcomes so every change is tested before release.

  5. Step 05

    Ship with tracing

    Log every step, tool call, and result, with alerts on failures, loops, and cost spikes.

Guardrails in every agent

GuardrailWhat it prevents
Tool allow-listCalling anything outside the job's scope
Argument validationMalformed or out-of-range values reaching your systems
Approval gatesIrreversible actions without a person's sign-off
Step and cost limitsRunaway loops and surprise bills
Content isolationInstructions hidden in emails or documents being treated as commands
Full traceUnexplained outcomes; every decision is reviewable

Agent or plain automation?

Agents are not always the answer. A fixed workflow is cheaper, faster, and easier to trust when it fits.

Use an agent when

  • Inputs are unstructured, such as emails or free text
  • The steps vary from case to case
  • Judgment is needed to choose between options

Use plain automation when

  • The steps are always the same
  • Inputs are already structured
  • A rule or a workflow can decide reliably

Before an agent goes live

  • Evaluation set passes at the agreed threshold
  • Every tool has its own scoped credential
  • Approval gates tested for each irreversible action
  • Cost per task measured and budgeted
  • Escalation path to a human defined
  • Monitoring and alerts in place

Common pitfalls we help you avoid

The most common pitfall is giving an agent too broad a goal. “Handle customer emails” fails in unpredictable ways; “classify the email, look up the order, and draft a reply for approval” succeeds because every step can be checked.

The second is skipping the evaluation set. Without real examples and expected outcomes, nobody can tell whether a prompt change made the agent better or worse, and regressions reach users first.

The third is treating cost and latency as afterthoughts. Agents that call large models many times per task can become slow and expensive at volume, so we measure both during the pilot and design around them.

What we measure

MeasureWhy it matters
Task success rateThe share of tasks completed correctly without help
Escalation rateHow often the agent hands over to a person, and why
Cost per taskModel and tool costs, compared with manual effort
Time per taskEnd-to-end latency users actually experience

Who does what

We handle

  • Agent design, tools, and guardrails
  • Evaluation sets and tracing
  • Deployment, monitoring, and improvement

Your team handles

  • Defining the job and approval rules
  • Examples of good and bad outcomes
  • Reviewing escalations during the pilot

A worked example

Imagine a distributor whose sales team receives dozens of requests for quotation by email each day. A quoting agent reads each email, identifies the customer in the CRM, matches requested items to products, checks stock and price lists, and saves a draft quote in the ERP with any unmatched lines highlighted.

A salesperson opens the draft, fixes the highlighted lines, and sends it. The agent never sends anything itself, and every step it took is visible in the trace. Over time, the evaluation set grows from real corrections, and the share of drafts sent without changes becomes the measure of progress.

Guidance we build on

Anthropic distinguishes workflows, where models and tools follow predefined code paths, from agents that choose their own steps, and recommends finding the simplest solution possible, adding complexity only when needed, with stopping conditions such as a maximum number of iterationsSource [1].

On security, OWASP ranks prompt injection first in its 2025 Top 10 for LLM applications, including indirect injection through websites and files an agent readsSource [2]. Its guidance on excessive agency names excessive functionality, permissions, and autonomy as root causes, and recommends minimal permissions and human approval for high-impact actionsSource [3]. Our agents get narrow tools, scoped credentials, and approval steps for anything irreversible.

Frequently asked questions

Are agents reliable enough for production?
For well-scoped tasks with guardrails, yes. Broad 'do anything' agents remain unpredictable, so we keep scope tight.
How do you prevent prompt injection?
Treat external content as data, restrict tools by context, validate tool arguments, and require approval for sensitive actions.
Can agents use our ERP?
Yes, through a scoped API user with only the permissions the agent's job needs.
What does it cost to run?
Model usage depends on volume and task length. We estimate cost per task during the pilot and monitor it in production.
Can we see what the agent did?
Every step, tool call, and result is traced and searchable.
Which model powers the agent?
We choose per task: hosted frontier models where reasoning quality matters, smaller or private models where cost, speed, or data residency matter more.
What happens when the agent gets stuck?
Step limits stop it, the case is handed to a person with the full trace, and the example is added to the evaluation set.
Can an agent work across several systems?
Yes, through one tool per system, each with its own permissions. The agent never holds a master credential.
How long does a first agent take to build?
A focused first agent usually reaches a supervised pilot in weeks rather than months; the evaluation set decides when it's ready for more autonomy.
Can agents run on a schedule?
Yes. Agents can be triggered by events, schedules, or users, with the same guardrails in each case.
Can an agent use our existing scripts and APIs?
Yes. Existing APIs and scripts can be wrapped as tools with typed inputs, permissions, and logging.
Do agents remember previous conversations?
Only what you choose to store. Memory is designed explicitly, with retention rules, rather than kept by default.
Can we start with a supervised mode?
Yes, and we recommend it: the agent proposes, a person approves, and autonomy grows as the numbers prove it out.
Do we need an agent or a workflow?
If the steps are known, a workflow is cheaper and easier to test. Agents suit tasks where steps can't be predictedSource [1].
How do you protect agents from malicious inputs?
Least-privilege tools, output validation, separation of untrusted content, and human approval for risky actions, following OWASP guidanceSource [2]Source [3].

Sources

  1. [1]Building effective agents (opens in a new tab)Anthropic, 19 December 2024
  2. [2]LLM01:2025 Prompt Injection (opens in a new tab)OWASP Gen AI Security Project, 2025
  3. [3]LLM06:2025 Excessive Agency (opens in a new tab)OWASP Gen AI Security Project, 2025