Software Architecture Patterns: Shared Repositories, Pipelines, Publish/Subscribe, and AI-Based Systems

Comprehensive vocabulary flashcards covering shared repositories, pipes and filters, publish/subscribe messaging, and AI-specific architectural patterns, layers, and forces.

Shared Repository Pattern

An architectural pattern in which a central data store maintains common application data accessed and modified by independent components, with the data state triggering the control flow.

Active vs. Passive Repository

The distinction where a passive repository relies on components querying it for updates, whereas an active repository proactively notifies components when data changes.

Pipes and Filters Pattern

An architectural pattern that divides complex data processing into a sequence of encapsulated steps (filters) connected by conduits (pipes) that transfer data batches or streams.

Filter

An independent component in a Pipes and Filters architecture that encapsulates a single processing subtask, shares no state with other components, and does not know its neighbors.

Pipe

A connector between adjacent filters that transfers data either as complete batches or as an incremental data stream while providing buffering.

Batch-Sequential Pipeline

A pipeline processing mode where each processing step completes fully before the next begins, handing off data as complete files or artifacts (such as in CI/CD stages).

Streaming Pipeline

A pipeline processing mode where pipes realize continuous data streams, enabling filters to incrementally consume and emit data with pipes acting as buffers.

Publish/Subscribe Pattern

A messaging pattern that extends the communication infrastructure with topics or message inspection to broadcast events from publishers to registered subscribers without direct coupling.

Event Broker

The central publish/subscribe messaging infrastructure component in an Event-Driven Architecture (EDA) that decouples producers and consumers by routing events.

Event Store

A central repository in an Event-Driven Architecture that records all events to provide an immutable history for auditing, debugging, and replaying.

Fallible Outputs

An AI-specific architectural force referring to the probabilistic nature of model outputs, which may be plausible yet incorrect, requiring validation before state changes occur.

Untrusted Input Steers Behavior

An AI security force arising because instructions and data share the same medium (text in context), enabling adversarial inputs and poisoned data to steer execution.

Probabilistic/Learned Runtime Control Flow Decisions

An AI architectural force where decision-making authority over the execution path is delegated at runtime to a learned probabilistic component or agent rather than hardcoded logic.

Costly and Slow/Variable Inference

An AI operational force where large model calls incur high monetary cost, substantial latency, and high runtime variance, requiring caching, batching, routing, and streaming.

Independent Evolution (AI Force)

An AI architectural force where models drift, get retrained, or are updated by providers behind stable APIs, requiring version pinning and abstraction to prevent system-wide ripples.

Ports and Adapters Pattern (AI Context)

An architectural structure where the application core interacts with external AI models through outbound ports acting as trust boundaries and anti-corruption layers, allowing easy adapter substitution.

Model Gateway

An intermediary architectural component between application cores and model services that handles routing (by task, cost, latency), retries, caching, rate limiting, budget enforcement, version pinning, and tracing.

Domain Layer (AI Artifacts)

The architectural layer where business-rule-encoding prompt templates, classification thresholds, output schemas, and invariant validation rules reside.

Application Layer (AI Artifacts)

The architectural layer responsible for orchestrating multi-step workflows (retries, budgets, cancellation) and constructing feature and context inputs for the model.

Infrastructure/Adapters Layer (AI Artifacts)

The edge architectural layer that isolates volatile technologies, including model clients, model serving gateways, model-provider-specific prompts, feature stores, and vector indexes.

Evaluator-Optimizer Pattern

A pipeline workflow pattern incorporating a feedback loop where an evaluator critiques a generator's outputs until an acceptance criterion is satisfied or a budget is exhausted.

Input Guard

A pipeline filter executed prior to model invocation that screens context for prompt injection and redacts sensitive personal data.

Output Guard

A pipeline filter placed after model inference that evaluates results against explicit output schemas, safety policies, and confidence thresholds before domain validation occurs.

Blackboard Pattern (AI Multi-Agent Context)

A shared repository adaptation where specialized agents coordinate by reading, writing, and refining a shared task state, inspection notes, and retrieved facts.

Event-Driven AI Architecture

An architecture using publish/subscribe infrastructure to handle slow model inference asynchronously and recording event history in an Event Store for replay-based evaluation.

Agent Loop

A runtime cycle where an LLM repeatedly reasons, plans, invokes actions or tools, observes execution results, and checks whether a predefined goal has been reached.

Agent Harness

The deterministic software environment wrapping an agent loop that controls turn context, memory, tool access, permissions, human approval, budgets, checkpoints, and step tracing.

Control-Flow Spectrum (AI Systems)

The architectural continuum of autonomy spanning from fixed pipelines (design-time decisions) and routers to orchestrator-worker workflows and open-ended agent loops.

Plan-Then-Execute Pattern

A structural defense mechanism in agent systems where the model first drafts a complete plan for harness validation and permission checks before any actions are executed.