The concept
An aggregate root enforces the rules of its cluster in one transaction, and other bounded contexts react to its domain events later, in theirs.
Domain-driven design (DDD) is an approach to complex software, set out by Eric Evans in his book of the same name, in which the code follows a model of the business, worked out with domain experts and spoken in one language inside an explicitly bounded context. This machine runs two of its patterns: the aggregate, inside one context, and the boundary between two contexts.
An aggregate is a cluster of entities and values changed as one unit. One entity is its root: code outside the aggregate holds references to the root only, and the root enforces the rules that span the cluster. A purchase order is the classic example: its lines may not total more than its approved limit, so a line is added through the order, never on its own.
The aggregate is also the unit of a transaction. A repository loads and saves the whole aggregate, and a version on the root, checked at each save, stops two users from committing changes that are each valid and together break the limit. Vaughn Vernon's rule of thumb: change one aggregate per transaction, and keep aggregates small.
A rule that spans aggregates, or bounded contexts, is kept eventually consistent. The root records a domain event, OrderPlaced; Shipping, a bounded context with its own model of a shipment, reacts to it later in its own transaction, and a delivery that fails is tried again. Sales does not wait for Shipping, and Shipping being down does not undo an order.
Here the event is saved in the same transaction as the order and published afterwards by a relay: the transactional outbox, one common way to do it. Evans and Vernon leave the mechanism open; what they ask is that changes cross an aggregate's boundary asynchronously.