# Key Concepts
## **What Is an Agent?**
An agent is an AI employee configured for a specific job. Every agent is built from the same three primitives:
1. **Instructions** — How the agent should behave. Tone, policies, escalation rules, tagging taxonomy. Written as a markdown document that's always in the agent's context. You shape instructions through chat or by editing them directly.
2. **Integrations** — What the agent can access and act on. Each integration provides:
* **Sources** — what the agent can read (help center articles, past tickets, Notion pages)
* **Triggers** — when the agent activates automatically (new ticket created, @mentioned, new message)
* **Actions** — what the agent can do (draft reply, send reply, tag ticket, look up order)
3. **Skills** — Extra workflows the agent can run on top of its core job. Skills are distinct from the agent's day-to-day work — they have their own steps, logic, and output artifacts. Example: running a Simulation skill to test accuracy against old tickets.
Every agent also has an **Activity** feed showing all its output in one place.
**Instructions vs. Knowledge — they're different:**
* **Instructions** = always in context. Defines HOW the agent behaves.
* **Knowledge** = searched when relevant. Reference material from integrations and uploaded files.
***
## **What Are Integrations?**
Integrations connect your agent to external services. They provide three things:
| Component | What It Does | Examples |
| --------- | ----------------------------------------------- | ----------------------------------------------------------------- |
| Sources | Data the agent reads and learns from | Help Center articles, past tickets, Notion pages, Google Docs |
| Triggers | Events that make the agent act automatically | New ticket created, @eesel mentioned, ticket assigned to bot |
| Actions | Things the agent can do in the external service | Draft reply, send reply, tag ticket, update status, look up order |
**Key behaviors:**
* Connecting an integration does NOT automatically activate it. You must explicitly enable triggers for the agent to act autonomously.
* All integration types are available on all tiers. Tiers limit the number of integrations, not which ones.
* Changes are live — no Save button. Toggle a trigger on and it's active immediately.
***
## What are instructions?
Instructions are how you tell your agent what to do. Think of them as the onboarding document you'd give a new team member — they define your agent's personality, rules, and behavior.
Good instructions include:
* **Who the agent is** — "You are a friendly support agent for Acme Corp"
* **How to respond** — "Keep answers concise. Use bullet points for steps."
* **What to do in specific situations** — "If the customer asks about billing, check their order status first"
* **When to escalate** — "If you can't answer confidently, assign to the Support team"
Where to find instructions
Open your agent and click the **Instructions** tab in the main content area. Instructions are written in plain text (markdown supported).
What to include
Good instructions cover four areas:
#### 1. Identity and role
Tell the agent who it is and what it does.
**Good example:**
```
You are a customer support agent for Acme Corp. You help customers
with product questions, troubleshooting, and account issues.
```
**Bad example:**
```
You are an AI.
```
#### 2. Response style
Define how the agent should communicate.
**Good example:**
```
Response guidelines:
- Be friendly and professional
- Keep answers concise — aim for 2-3 short paragraphs
- Use bullet points for step-by-step instructions
- Always greet the customer by name if available
- End with "Is there anything else I can help with?"
```
**Bad example:**
```
Be nice.
```
#### 3. Handling specific situations
Give clear rules for common scenarios.
**Good example:**
```
Specific rules:
- For billing questions: Check the customer's account status first,
then provide relevant information
- For bug reports: Ask for the browser/device, steps to reproduce,
and any error messages. Then assign to the Engineering team
- For feature requests: Thank the customer, tag as "feature-request",
and let them know the product team reviews all requests
- For cancellation requests: Empathize, ask for the reason, offer
alternatives if appropriate, then assign to the Retention team
```
#### 4. Escalation rules
Define exactly when the agent should hand off to a human.
**Good example:**
```
Escalation rules:
- If you are not confident in your answer, assign to Support Tier 2
- If the customer asks to speak with a human, assign immediately
- If the customer mentions legal action, assign to the Legal team
- If the issue involves a security concern, assign to Security with
a high-priority tag
- Never attempt to handle refunds over $100 — assign to a manager
```
**Bad example:**
```
Escalate if needed.
```
Template by use case
#### Support agent
```
You are a support agent for [Company Name]. You help customers with
questions about [Product].
Response style:
- Professional and friendly
- Concise answers (2-3 paragraphs max)
- Use bullet points for instructions
- Include relevant links when available
When answering:
1. Search your knowledge base for the answer
2. If found, provide a clear, helpful response
3. If not found, let the customer know and assign to a human agent
Escalation rules:
- Billing disputes → Billing Team
- Bug reports → Engineering
- Can't find an answer → Support Tier 2
- Customer requests a human → Assign immediately
```
#### Triage agent
```
You are a ticket triage agent for [Company Name]. Your job is to
categorize and route incoming tickets — you do NOT reply to customers.
For each ticket:
1. Read the content carefully
2. Tag with one category: billing, bug, how-to, feature-request, account
3. Route based on category:
- billing → Billing Team
- bug → Engineering
- how-to → Support Tier 1
- feature-request → Product
- account → Support Tier 1
4. Set priority: urgent / high / normal
5. Leave an internal note explaining your categorization
```
#### Knowledge agent
```
You are an internal knowledge assistant for [Company Name]. Team
members ask you questions about company policies, processes, and
documentation.
Guidelines:
- Answer based only on the documentation you have access to
- If you don't have the answer, say so clearly
- Always link to the source document when possible
- Keep answers concise and actionable
- Use a casual, helpful tone (this is an internal team tool)
```
Tips for better instructions
**Be specific.** Vague instructions lead to inconsistent behavior. Instead of "be helpful," define exactly what helpful looks like.
**Include examples.** If you want responses formatted a certain way, show an example in the instructions.
**Iterate based on testing.** Test in the chat panel, see what the agent gets wrong, and refine instructions accordingly.
**Don't overload.** A focused set of clear rules works better than a long list of edge cases. Start simple and add rules as you discover gaps.
**Use the chat assistant.** The AI assistant in the right panel can help you write and refine instructions.
***
## **What Are Skills?**
Skills are distinct multi-step workflows an agent can run on top of its core job. A skill earns its existence when it has its own steps and output artifact — not just a single tool call.
**What's NOT a skill:** The agent's core behavior (drafting replies, tagging tickets, writing posts) emerges from integrations + instructions. That's the core job, not a skill.
**Running skills:**
* **On-demand:** Click Run or ask in chat ("Run simulation on 200 tickets from last 60 days")
* **Scheduled:** Set up via Settings > Schedules (Daily/Weekly/Monthly at a specific time)
Skill availability by tier:
| Tier | On-demand Skills | Scheduled Skills |
| ---------- | ---------------- | ---------------- |
| Junior | — | — |
| Senior | — | — |
| Manager | All | All |
| Enterprise | All | All |
***
## **Building Trust (Observe, Verify, Automate)**
eesel agents are designed for gradual trust building — you start fully supervised and expand autonomy over time.
**The progression:**
1. **Test in dashboard** — Chat with your agent, ask questions, verify answers. No customer impact.
2. **Draft mode (HITL)** — Agent processes real tickets but every reply requires your approval before sending. You see the draft, edit if needed, then approve or reject.
3. **Semi-autonomous** — After a track record ("You approved 94% without edits this week"), the agent suggests automating routine responses while still escalating edge cases.
4. **Fully autonomous** — Agent handles tickets end-to-end. You monitor via daily recaps, analytics, and exception alerts.
**Human-in-the-Loop (HITL) — how it works:**
1. Agent processes a ticket and reaches the "Send reply" action (configured as HITL).
2. Action pauses. Notification appears on your Home dashboard and optionally via email.
3. You open the ticket log, see the draft, and can edit the text.
4. Click **Approve** to send, or **Reject** to request a revision.
5. If rejected, the agent asks for feedback in Chat, regenerates, and you review again.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.eesel.ai/getting-started/key-concepts.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.