> ## Documentation Index
> Fetch the complete documentation index at: https://docs.scoutos.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Scout Core Concepts: Agents, Workflows, and Databases
> Understand the core building blocks of Scout: agents, instructions, databases, drive, syncs, observability, and workflows — with practical examples.
Scout is built around a set of composable building blocks — agents, instructions, data storage, syncs, observability, and workflows. Understanding how these pieces fit together helps you move from experimenting with templates to building production-ready automations that run reliably at scale. This page walks you through each concept with practical examples and clear definitions.
***
## Agents
Agents are AI assistants that take action across your tools. You give an agent a goal; it figures out the steps to achieve it. Unlike a chatbot that answers questions and waits, a Scout agent connects to your tools, makes decisions, and executes tasks autonomously.
**Create an agent:** Scout Studio → Agents. Connect your tools, write instructions, and let it run.
| Chatbots | Scout Agents |
| --------------------- | ---------------------------------------- |
| Answer questions | Take action |
| Wait for instructions | Figure out the steps independently |
| Single conversation | Remember context across sessions |
| One tool at a time | Connect to all your tools simultaneously |
**Example:** *"Research our top 5 competitors and summarize their pricing."*
The agent finds the competitors, searches for pricing pages, handles cases where pricing isn't publicly listed, and delivers a structured summary — all without step-by-step instructions from you.
***
## Instructions
Instructions are the natural language you write to define an agent's behavior. They tell the agent what to do, how to act, and what to prioritize. Think of them less like a one-time prompt and more like a job description — instructions persist across every run of the agent.
**Write instructions:** Studio → Agents → select your agent → Instructions field.
**What makes instructions effective:**
* Be specific about the goal, not just the task
* Describe the output format you expect
* Give context about who the agent is helping
* Explain how to handle edge cases or missing data
Here's the difference in practice:
**Vague:**
```text theme={null}
Research competitors.
```
**Specific:**
```text theme={null}
Research our top 5 SaaS competitors. For each, find their pricing
page, free tier limits, and top 3 integrations. If pricing isn't
publicly listed, note that explicitly. Return results as a table
with one row per competitor.
```
The specific version defines scope, sets expectations for incomplete data, and specifies the output format. That's what gets you a useful result on the first run — not after several rounds of back-and-forth.
**Instructions vs. prompts:** Instructions are persistent and shape every run of the agent. A prompt is a one-time request sent during a conversation. Use instructions to set the agent's default behavior; use prompts to make one-off requests.
***
## Databases
Databases are Scout's structured data storage layer — your agent's personal library. Use them to store documents, customer data, product information, or any structured content your agents need to search and retrieve.
**Create a database:** Studio → Databases. Define a schema with column types like text, number, select, datetime, or relation.
* **Databases** are top-level containers that group related data together
* **Tables** store structured records within a database, with defined schemas
**What you can do with databases:**
* Store product catalogs, FAQs, customer records, or knowledge base articles
* Let agents search and retrieve information by meaning using built-in vector search
* Sync data automatically from external sources (see [Syncs](#syncs) below)
**Example:** Upload your product catalog to a database. Now any agent can answer customer questions about specs, pricing, and availability — by searching the database semantically, not just by keyword match.
***
## Drive
Drive is Scout's file storage layer for documents, images, and assets your agents need to read, write, or reference.
**Upload files:** Studio → Drive. Organize into folders. Agents can read and write files directly.
**Common use cases:**
* Upload PDFs for an agent to analyze and extract data from
* Store images for processing or transformation workflows
* Share assets (templates, reference files, exports) across multiple workflows
Drive and Databases serve different purposes. Drive is for files (PDFs, images, CSVs). Databases are for structured, searchable records. Use whichever matches the shape of your data.
***
## Syncs
Syncs let you import data from external sources into your Databases automatically. Set up a sync once, and Scout keeps your data current without any manual effort.
**Configure a sync:** Studio → Syncs. Select a source, map fields to your database tables, and set a refresh schedule.
**Supported sources:**
| Source | What Gets Imported |
| ------------- | ----------------------------------- |
| Websites | Crawled and scraped page content |
| Sitemaps | Bulk page imports from XML sitemaps |
| Notion | Pages and databases |
| Google Drive | Docs, Sheets, and Slides |
| Microsoft 365 | SharePoint and OneDrive content |
| Laserfiche | Enterprise document repositories |
**How it works:** Point a sync at your source, map its fields to your database schema, and Scout handles the rest — pulling updates on your chosen schedule so your agents always work with fresh data.
***
## Observability
Observability gives you a clear view of what your agents are doing — every action logged, every decision traceable. This is how you build trust in your automations: not by hoping things worked, but by seeing exactly what happened.
**Activity Logs** show you:
* When an agent ran and what it completed
* How long each step took
* Whether each step succeeded or failed
**Execution Traces** show you:
* Which tools were called and in what order
* What decisions the agent made at each step
* Why the agent chose a particular approach
**Tool Usage** shows you:
* **Reads:** Documents, databases, and APIs the agent queried
* **Writes:** Content the agent created, updated, or sent
* **External calls:** Third-party services the agent contacted
Use execution traces when an agent produces an unexpected result. Traces let you pinpoint exactly where the behavior diverged from what you intended, so you can update instructions or fix the workflow quickly.
***
## Workflows
Workflows are automated sequences triggered by events or schedules. They connect your tools, execute logic, and run reliably at scale — no code required.
**Build a workflow:** Studio → Workflows. Drag and drop blocks to create logic flows, then connect a trigger to activate it.
### Triggers
A trigger is what starts a workflow. Scout supports four types:
| Trigger Type | Example |
| ---------------------- | ------------------------------------------------------ |
| **Webhook** | A form submission fires a POST request to Scout |
| **Schedule (cron)** | Run every weekday at 9:00 AM |
| **Event** | An agent completes a task; a file is uploaded to Drive |
| **Native integration** | A new calendar event is created; an email arrives |
### Blocks
Blocks are the individual steps inside a workflow. Each block does one job:
| Block Type | What It Does |
| -------------------- | ------------------------------------------------------ |
| **Action Blocks** | Make API calls, write to databases, send notifications |
| **Agent Blocks** | Run a Scout AI agent as a step in the workflow |
| **Condition Blocks** | Branch logic based on if/else conditions |
| **Transform Blocks** | Modify, reshape, or enrich data between steps |
**Example workflow:** New lead from website → Research the company → Enrich the CRM record → Draft a personalized outreach email → Notify the sales rep in Slack.
Each arrow in that sequence is a block. The whole thing runs automatically whenever a new lead arrives.
***
## Key Terms
| Term | What It Means |
| ---------------- | ------------------------------------------------------------------------------------------------- |
| **Agent** | An AI assistant that takes action across your tools |
| **Workflow** | An automated sequence triggered by events or schedules |
| **Database** | A top-level data container in Scout — Tables of structured records, your agent's personal library |
| **Table** | Structured data records within a database |
| **Drive** | File storage for documents, images, and assets |
| **Sync** | Automatic data import from an external source |
| **Instructions** | Persistent natural language guidance that shapes agent behavior |
| **Context** | The data, files, and history an agent works with on a given run |
***
## Next Steps
Build your first agent using a pre-built template — no code required.
Go deeper on triggers, blocks, and building production workflows.
Learn how to store, structure, and sync data for your agents.
See every tool and service your agents can connect to.