> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bindai.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# 07.2 applications

# Applications

An **Application** is a self-contained AI service within a BindAI project.

Applications group together agents, workflows, configuration, and execution logic for a specific business purpose.

A single project may contain multiple independent applications that share common resources while serving different users or use cases.

***

# What is an Application?

An application is the primary runtime unit inside a project.

Conceptually:

```text theme={null}
Project

↓

Application

↓

Agents

↓

Responses
```

Applications define how users interact with your AI system.

***

# Why Applications?

Large AI systems often solve multiple business problems.

For example:

* Customer Support
* Internal Knowledge Assistant
* Sales Automation
* Document Analysis
* Code Review

Each of these can be implemented as a separate application within the same project.

***

# Application Architecture

A typical application contains:

```text theme={null}
Application

├── Agents

├── Workflows

├── Configuration

└── Runtime
```

Applications may also access shared project resources such as tools and knowledge.

***

# Multiple Applications

A project can host multiple applications simultaneously.

```text theme={null}
Project

├── Support App

├── HR Assistant

├── Finance Assistant

└── Analytics App
```

Each application operates independently while sharing common infrastructure.

***

# Agents Inside Applications

Applications own one or more agents.

```text theme={null}
Application

↓

Support Agent

↓

Language Model
```

Each agent performs a specific reasoning task within the application's domain.

***

# Shared Resources

Applications can reuse project-level resources.

Examples include:

* shared tools
* shared workflows
* shared knowledge bases
* shared memory providers

This encourages consistency and avoids duplication.

***

# Running an Application

Applications provide a simple execution interface.

Conceptually:

```python theme={null}
result = project.run(
    application="support",
    agent="assistant",
    message="Hello",
)
```

The application locates the requested agent and executes it.

***

# Streaming Responses

Applications also support streaming output.

```text theme={null}
User

↓

Application

↓

Agent

↓

Streaming Response
```

Streaming is useful for chat interfaces where responses are displayed as they are generated.

***

# Workflow Integration

Applications may invoke workflows instead of individual agents.

```text theme={null}
User Request

↓

Application

↓

Workflow

↓

Agents

↓

Result
```

This enables complex orchestration while keeping the application interface simple.

***

# Configuration

Each application can have its own configuration.

Examples include:

* default model
* available agents
* enabled workflows
* provider settings
* application metadata

Application configuration remains isolated from other applications.

***

# Separation of Responsibilities

Applications should focus on a single domain.

Good examples:

```text theme={null}
Customer Support

Human Resources

Finance

Engineering
```

Avoid creating one application that attempts to solve every problem.

***

# Application vs Project

These concepts serve different purposes.

| Project                        | Application                   |
| ------------------------------ | ----------------------------- |
| Top-level container            | Individual AI service         |
| Contains multiple applications | Contains agents and workflows |
| Shared resources               | Domain-specific behavior      |
| Infrastructure                 | Runtime entry point           |

Projects organize.

Applications execute.

***

# Typical Structure

An application may look like this:

```text theme={null}
support/

├── agents/

├── workflows/

├── prompts/

├── configuration/

└── resources/
```

The exact layout depends on the project's requirements.

***

# Best Practices

* Create one application per business domain.
* Keep application responsibilities focused.
* Reuse shared project resources.
* Register only the agents needed by that application.
* Keep configuration local to the application whenever possible.
* Prefer several focused applications over one monolithic application.

***

# Summary

Applications are the runtime services inside a BindAI project.

They organize agents, workflows, and configuration into focused AI solutions while sharing common project infrastructure such as tools, knowledge, and scheduling.