Agentic AI
in practice
A support desk agent that reads the ticket, finds the answer, and drafts the reply for a person to send. Run centrally, under your company's control.
Andreas Cambitsis · with Yehuda King
A support desk agent, from idea to live
Where it runs
On your laptop, or run centrally by your company.
What it does
Reads the ticket, finds the answer, drafts the reply. A person sends it.
Show
A real ticket, start to finish.
Build
How the same agent is put together on Amplify.
Follow-up session: authentication, network security, and building connectors with skills, in depth.
Where an agent runs
Why running agents centrally, under your company's control, changes what you can safely hand them.
Where an agent runs decides what you can trust it with
An agent on someone's laptop
Coding agents and desktop assistants: Claude Code, Codex, Cowork and the like
- It runs with that person's logins and that person's files.
- Everyone sets up their own copy, and no two are the same.
- Changes live on one machine. There's no shared version.
- The organisation can't see what it did.
- Brilliant for one skilled person.
An agent your company runs centrally
The Amplify Agent Runtime
- It runs in your own cloud environment, in its own sandbox for every conversation.
- You sign in with your work identity. Access is by group.
- It's versioned, reviewed and deployed like software.
- Every tool call and every change is logged.
- Built once, shared by the team, permissions under control.
What the Amplify Agent Runtime gives you
It runs in your environment
In your own cloud. Every conversation gets its own sandbox, files and network rules.
Your work login
You sign in with your company account. Who can use, edit or publish an agent is a group setting.
Version control, built in
Instructions, knowledge and skills live in the agent's own repository. Every change is a commit.
Test before you publish
Draft, Preview and Production. A route decides which version people actually get.
Nobody handles passwords
The runtime holds the secrets. The model and the prompt never see them.
You can see everything it did
Tool calls, knowledge lookups, changes and deployments are all logged and reviewable.
Agent changes are tracked, tested and reversible
Everything in the agent is versioned
Instructions, every knowledge file, every skill. Once a version is released it can't change.
Going back is one switch
Production holds two versions. If something's wrong, point the route back. No rebuild.
People own promotion
The agent can propose a change. Only a person moves it from Draft to Live.
Skills: instructions plus code
What a skill is
- A folder with a
SKILL.md: a name, a description, instructions. - Plus, if you want, scripts the agent can run.
- The agent sees the names and loads a skill when it needs one.
- An open industry standard, not an Amplify format.
Why it matters
- A skill with a script is a connector to any system with an API.
- The runtime supplies the sign-in, so it can call that API safely.
- It's versioned with the agent. The agent can even write one, in Draft.
The agent signs in as you
What this means
- The model never sees the secret. The prompt never contains it.
- The agent acts as you, with your permissions in the target system.
- The sandbox can only reach hosts on its allow list.
What you do, and don't do
- You sign in once, with the account you already use for Zoho Desk.
- You never paste a password or key anywhere.
- The draft carries your name, because the agent worked as you.
Knowledge that is found reliably, and kept current
It finds the right page
- Search by exact words: error codes, product names.
- Search by meaning, when the customer's words differ from the page.
- The best passages are put first.
- Different phrasings of the same question still match.
Versioned with the agent
- Knowledge files are part of the agent's repository.
- Restore an old version and the knowledge comes back with it.
- Every change has an author and a reason.
Updated from the conversation
- The agent can add, replace or delete a knowledge file.
- The change lands in Draft. Never straight to Live.
- A person reviews it and publishes.
What this opens up
Any system with an API is within the agent's reach
A skill with a script, plus a brokered credential. No connector product to buy, no middleware to run.
Your permissions carry through
The agent does what you're allowed to do, in the target system, as you.
Knowledge that compounds
Every resolved ticket can improve the knowledge base, through review, for the next ticket.
Agents run like products
Versions, environments, rollback and audit, for something that used to be a prompt in a text box.
The support desk agent
What it does when a ticket arrives, what it needs to get the answer right, and where a person stays in charge.
The support desk agent, step by step
Two human checkpoints
The reply stays a draft until a person sends it.
The knowledge change stays in Draft until a person publishes it.
Everything in between is driven from one chat.
The same flow, mapped onto Amplify
Ticket in, draft out, knowledge improved
First what it does. Then how it's built. The second half is the technical one.
Demo.
A real ticket in Zoho Desk, start to finish. Then how the agent is built.
Takeaways
Run agents centrally, under company control
In your own cloud environment, under your company identity, with everything logged. That's what makes it safe to connect customer systems.
One skill connects any system
One folder and one script connect any API. The runtime handles the secrets.
Shape knowledge so it can be found and checked
FAQ-shaped, marked by audience, with a source. Let the agent propose. Let people publish.
Ship agents like software
Draft, review, preview, production, rollback. It's built in.
Questions.
amplify360.ai