Apps, Agents & Skills Overview

Horizon is built on a three-tier hierarchy that keeps your AI automations organized, composable, and maintainable. Every piece of functionality in the platform fits into this model.

The hierarchy

+------------------------------------------+
|                  APP                     |
|  A deployable bundle (e.g. "Accounting  |
|  Assistant," "Sales Pipeline Manager")  |
|                                          |
|  +------------------+  +--------------+  |
|  |     AGENT A      |  |   AGENT B    |  |
|  |  Instructions    |  | Instructions |  |
|  |  Memory          |  | Memory       |  |
|  |  Model config    |  | Model config |  |
|  |                  |  |              |  |
|  |  +-----+ +-----+|  | +-----+     |  |
|  |  |Skill| |Skill||  | |Skill|     |  |
|  |  |  1  | |  2  ||  | |  3  |     |  |
|  |  +--+--+ +--+--+|  | +--+--+     |  |
|  +-----|------|-----+  +----|--------+  |
+---------+------+-----------+-----------+
          |      |           |
     +----v--+ +-v------+ +-v---------+
     |QuickBooks| Slack  | Sage Intacct|
     +---------+ +-------+ +-----------+
        External Services

Apps

An App is a deployable bundle that packages one or more agents together with their configuration. Think of an app as a finished product that solves a specific business problem.

• Self-contained — an app includes everything it needs: agents, skill assignments, default instructions, and model settings.
• Installable — you can install apps from the Horizon Store with a single click, or build your own from scratch.
• Versioned — apps can be published with version numbers, letting you roll back to a previous release if something goes wrong.
• Shareable — once you build an app, you can publish it to the Store for others in your organization (or the wider Horizon community) to use.

Examples of apps: “Accounting Assistant,” “Sales Pipeline Manager,” “Weekly Report Generator,” “Customer Onboarding Bot.”

Agents

An Agent is an AI-powered entity that lives inside an app. Each agent has its own identity and capabilities:

Component	Purpose
Instructions	System prompt that defines the agent’s persona, constraints, and behavior
Memory	Working, episodic, and semantic memory layers that let the agent recall context
Model	The underlying AI model (and configuration) powering the agent’s reasoning
Skills	The set of capabilities the agent can invoke to interact with external services

Agents are what your team actually interacts with. You talk to agents through conversations in the Horizon dashboard, via Slack or Microsoft Teams, or through the API. A single app can contain multiple agents that collaborate or handle different aspects of a workflow.

Tip

A good mental model: an agent is like a new team member. You give them instructions (what to do), memory (context about past work), access to tools (skills), and a brain (model). The better you configure each of these, the more effective the agent becomes.

Skills

A Skill is an atomic capability that an agent can invoke. Skills are the bridge between an agent’s reasoning and the outside world.

Each skill:

• Connects to one external API — such as QuickBooks, Sage Intacct, Slack, or a web service.
• Has defined parameters — structured inputs that the agent fills in based on the conversation context.
• Handles the hard parts — authentication, data formatting, error handling, retries, and rate limiting are built into the skill layer.
• Returns structured data — the agent receives clean, usable results that it can reason about and present to the user.

Skills are intentionally small and focused. Rather than one massive “QuickBooks” skill, Horizon provides individual skills like “Profit & Loss Report,” “Query Customer,” and “Customer Upsert.” This granularity lets you assign exactly the capabilities each agent needs — nothing more, nothing less.

How the layers work together

1. A user sends a message to an agent (through the dashboard, Slack, or the API).
2. The agent reads its instructions and checks its memory for relevant context.
3. The agent’s model reasons about the request and decides which skill(s) to invoke.
4. The skill executes against the external service, handling auth and data formatting.
5. The agent receives the skill’s response, reasons about it, and replies to the user.
6. The interaction is stored in the agent’s memory for future reference.

This loop can repeat multiple times within a single conversation — an agent might invoke several skills in sequence to fulfill a complex request.

Explore further

Creating Agents Learn how to create agents from Store templates or from scratch.

Writing Instructions Craft effective system prompts that shape agent behavior.

QuickBooks Skills Explore the full set of QuickBooks financial skills.

Sage Intacct Skills Query AP, AR, GL, budgets, projects, and custom reports.