> For the complete documentation index, see [llms.txt](https://docs.xplatform.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.xplatform.com/talon/concepts-and-architecture.md).

# Concepts & Architecture

## Overview

Talon is a high-performance microservices platform designed for building ultra-low latency, fault-tolerant distributed systems. This section provides a comprehensive understanding of Talon's core concepts, architectural patterns, and operational models.

Understanding these concepts is essential for:

* **Architects** designing Talon-based systems
* **Developers** building Talon microservices
* **Operators** managing Talon deployments
* **Technical decision-makers** evaluating Talon for their use cases

## What You'll Learn

This section covers the foundational concepts and architectural patterns that underpin the entire Talon platform. Each topic builds on the others to provide a complete mental model of how Talon works.

### Core Architecture

[**Messaging Model**](/talon/concepts-and-architecture/messaging-model.md) - How microservices communicate

Talon's messaging abstraction provides a unified interface for message exchange across different messaging backbones (Solace, JMS, etc.). Learn how:

* Messages are modeled as strongly-typed POJOs
* Channel subscriptions and message routing work
* Different messaging bindings integrate with the platform
* Message delivery guarantees are provided

[**Microservice Architecture**](/talon/concepts-and-architecture/microservice-architecture.md) - The anatomy of a Talon microservice

Understand the structure of a Talon microservice:

* [Runtime Architecture](/talon/concepts-and-architecture/microservice-architecture/runtime-architecture.md) - The runtime components (AEP Engine, SMA, XVM, etc.)
* [Development Model](/talon/concepts-and-architecture/microservice-architecture/development-model.md) - Development artifacts (ADM models, user code, configuration)
* [Configuration Model](/talon/concepts-and-architecture/microservice-architecture/configuration-model.md) - How configuration is managed and applied

### Operational Concepts

[**Microservice Operation**](/talon/concepts-and-architecture/microservice-operation.md) - How microservices behave at runtime

Follow a microservice through its complete lifecycle:

* [Lifecycle](/talon/concepts-and-architecture/microservice-operation/lifecycle.md) - Complete microservice lifecycle with all phases and events
* [Initialization](/talon/concepts-and-architecture/microservice-operation/cluster-initialization.md) - How microservices start up and initialize
* [Cluster Join](/talon/concepts-and-architecture/microservice-operation/cluster-join.md) - How instances discover and join clusters
* [Message Processing](/talon/concepts-and-architecture/microservice-operation/message-processing.md) - The message processing loop and transaction flow
* [Cluster Consensus](/talon/concepts-and-architecture/microservice-operation/cluster-consensus.md) - How distributed consensus is achieved
* [Cluster Failover](/talon/concepts-and-architecture/microservice-operation/cluster-failover.md) - Handling primary failures and backup promotion

### High Availability & Consistency

[**Consensus Models**](/talon/concepts-and-architecture/consensus-models.md) - State Replication vs Event Sourcing

Talon provides two consensus models for achieving high availability:

* **Event Sourcing** - Replicate inbound messages for deterministic state reconstruction
* **State Replication** - Replicate state changes automatically

Understand the trade-offs between latency, complexity, and flexibility.

[**Transactions**](/talon/concepts-and-architecture/transactions.md) - ACID guarantees in distributed systems

Learn how Talon provides transactional guarantees:

* Atomic commits of state changes and outbound messages
* Transaction isolation and consistency
* Integration with consensus models
* Savepoints and transaction control

### Platform Services

[**Threading Model**](/talon/concepts-and-architecture/threading-model.md) - How Talon manages concurrency

Talon's single-threaded business logic model eliminates race conditions while maintaining high throughput:

* Thread architecture and responsibilities
* Disruptor-based event processing
* Thread affinitization for performance
* NUMA-aware configuration

[**Discovery Model**](/talon/concepts-and-architecture/discovery-model.md) - How components find each other

The discovery service enables microservices to locate:

* Other microservice instances for clustering
* XVM containers for deployment
* Message buses for connectivity
* Discovery providers (Multicast, SMA, Local)

[**Operating Model**](/talon/concepts-and-architecture/operating-model.md) - Administration, monitoring, and troubleshooting

Understand the operational aspects:

* Statistics collection and heartbeats
* Administrative commands and control
* Analysis and troubleshooting tools
* Performance monitoring

## Architecture Principles

Talon's architecture is guided by several key principles:

### 1. Event-Driven Processing

All business logic executes in response to events (messages, lifecycle events, timer events). This ensures deterministic, reproducible behavior across instances.

### 2. Single-Threaded Business Logic

Message handlers execute on a single thread, eliminating the need for locks, mutexes, or concurrent data structures in application code.

### 3. Transparent High Availability

Clustering, replication, and failover happen automatically without application code changes. The platform handles distributed consensus.

### 4. Message-Oriented Architecture

Communication between microservices happens exclusively through messages. This loose coupling enables independent deployment and scaling.

### 5. Strong Typing

All messages and state are strongly-typed POJOs generated from declarative models. This eliminates serialization errors and provides compile-time safety.

### 6. Configuration as Code

All runtime configuration is expressed in declarative XML (DDL) with support for templating, profiles, and overrides.

## How These Concepts Fit Together

Here's how the concepts relate to building and running a Talon microservice:

1. **Development**: Use the [Development Model](/talon/concepts-and-architecture/microservice-architecture/development-model.md) to understand what artifacts you create (ADM models, handlers, configuration)
2. **Runtime**: The [Runtime Architecture](/talon/concepts-and-architecture/microservice-architecture/runtime-architecture.md) shows how those artifacts are loaded and executed by the AEP Engine, SMA, and XVM
3. **Communication**: The [Messaging Model](/talon/concepts-and-architecture/messaging-model.md) explains how your microservice sends and receives messages via the SMA
4. **Lifecycle**: [Microservice Operation](/talon/concepts-and-architecture/microservice-operation.md) describes what happens from startup through steady-state processing to shutdown
5. **High Availability**: [Consensus Models](/talon/concepts-and-architecture/consensus-models.md) and [Transactions](/talon/concepts-and-architecture/transactions.md) explain how consistency and fault tolerance are achieved
6. **Performance**: The [Threading Model](/talon/concepts-and-architecture/threading-model.md) and [Discovery Model](/talon/concepts-and-architecture/discovery-model.md) describe how Talon achieves ultra-low latency
7. **Operations**: The [Operating Model](/talon/concepts-and-architecture/operating-model.md) covers monitoring, administration, and troubleshooting

## Next Steps

After understanding the concepts in this section, proceed to:

* [**Developing Applications**](/talon/developing-applications.md) - Put these concepts into practice by building microservices
* [**Microservice Template**](/talon/developing-applications/microservice-template.md) - Start with template projects for Event Sourcing or State Replication
* [**Reference**](/talon/reference.md) - Look up specific annotations, events, and configuration elements

## Additional Resources

For hands-on learning:

* Start with [Get Started](/get-started/set-up-your-dev-environment.md) to set up your development environment
* Review [Introduction](/talon/introduction.md) for a high-level overview of Talon
* Explore the [Microservice Template](/talon/developing-applications/microservice-template.md) section for complete implementation examples


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.xplatform.com/talon/concepts-and-architecture.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.