Glossary

This glossary defines terms as they are used within the Swiss AI Hub platform. Where a term has a broader industry meaning, the definition here reflects the platform-specific usage.

Domain terms

Term	Definition
Agent	A dispatchable workflow that performs structured operations on input data to achieve a pre-defined goal. Agents are autonomous AI components designed for proactive process automation, working alongside humans to execute tasks.
Agent blueprint	The code-level definition of an agent (also called agent class). Contains workflow steps, form schema, event specifications, and default configuration. Discovered automatically when agents come online. User-friendly term for "agent class".
Agent profile	A user-created configuration of an agent blueprint (also called agent instance). Has a unique ID, name, description, icon, and specific settings. Multiple profiles can be created from one blueprint. User-friendly term for "agent instance".
Profile template	A predefined data-mode AgentConfig instance declared in Python code and transmitted during agent discovery. Templates prefill the Admin UI form when creating new profiles, but never auto-create profiles.
Process	An orchestrated multi-step workflow that coordinates agents, humans, and external programs. Processes use @process_step-decorated methods with typed delegation (Agent.In, Human.Out, Program.Out) and persist state in FerretDB.
Walkthrough	A single execution instance of a process, analogous to a run for an agent. Each walkthrough tracks its current step, accumulated work events, and delegation state.
Pipeline	A complete data processing workflow that transforms source data through multiple stages to produce final outputs, typically from document ingestion to vector embeddings. The platform uses a two-stage pipeline: Stage 1 handles source-specific document observation and download, Stage 2 handles source-agnostic parsing, chunking, embedding, and indexing.
Knowledge database	A logical namespace in Milvus that groups vector embeddings from processed documents. Agents reference knowledge databases by name in their configuration to enable RAG retrieval.
Thread	A logical grouping of multiple runs that form a continuous conversation. Maintains state across runs via persistent ThreadContext for contextual follow-up interactions. Threads carry participant lists for access control and serve as the top-level scope in the event subject hierarchy.
Display	A grouping within a thread that determines what the UI renders together in one logical interaction. A single thread can contain multiple displays (e.g., separate question-answer exchanges).
Run	A single, traceable execution of an agent's workflow, beginning with a StartEvent and ending with a StopEvent. Has an ephemeral RunContext for state management. The run serves as the execution_context_id for step tracking, event replay, and crash recovery.
Tier	One of four capability levels that describe how organizations adopt the platform. Tier 1: secure LLM access. Tier 1+: channel integrations (Teams, Slack). Tier 2: document pipelines and custom agents. Tier 3: process orchestration with human-in-the-loop workflows. All tiers ship in a single deployment.
Data lake	The SeaweedFS-backed storage layer where ingested documents are stored after download and before processing. Stage 1 pipeline assets write DataLakeFile objects to the data lake; Stage 2 assets consume them regardless of their source origin.
Tenant	An isolated organizational unit within a multi-tenant deployment. Each tenant has its own users, roles, agent configurations, and data. Multi-tenancy is not yet implemented; the platform currently operates as single-tenant.

Protocol and event terms

Term	Definition
Swiss AI Agent Protocol	The event-driven communication protocol over NATS that governs all inter-component interaction. Defines the event hierarchy, subject naming conventions, and the separation between control and display events.
Control event	An event that drives workflow state transitions. Control events are published to NATS JetStream for durable delivery and trigger step execution in the dispatcher. Examples: StartEvent, StopEvent, HumanInTheLoopRequestEvent.
Display event	An event that provides observability data for frontends and tracing systems. Display events are published to NATS Core for ephemeral real-time delivery. Losing display events does not affect workflow correctness. Examples: ChunkEvent, ThoughtEvent.
Control-and-display event	An event that serves both purposes simultaneously. Published to both JetStream (durable) and NATS Core (ephemeral). Most concrete events inherit from ControlAndDisplayEvent.
Semantic event	A ControlAndDisplayEvent subclass that implements to_semantic_convention(), returning OpenInference-compatible attribute dictionaries. Semantic events are simultaneously NATS workflow events and OpenTelemetry trace data. Examples: LLMEvent, RetrieverEvent, GuardEvent.
Event registry	The class-level dictionary populated by __pydantic_init_subclass__ at import time. Maps _event_name strings to event subclasses, enabling polymorphic deserialization. Unknown event names fall back to the nearest known ancestor via _parent_event_names.
Topic	A structured NATS subject string that encodes routing information. Agent topics follow agent.{class}.{id}.{thread}.{display}.{run}.{event_type}.{event_name}.{event_id}. Process topics follow process.{class}.{id}.{walkthrough}.{event_type}.{event_name}.{event_id}.
Work event	Events that signal successful completion of work by entities. Include AgentWorkEvent, HumanWorkEvent, ProcessWorkEvent, and ProgramWorkEvent.
Work request event	Events that delegate work to specific entities. Include AgentWorkRequestEvent, HumanWorkRequestEvent, and ProgramWorkRequestEvent.

Agent terms

Term	Definition
Agent configuration	A Pydantic model inheriting from AgentConfig that defines agent settings, parameters, and behavior. Uses the form duality pattern with Annotated fields for both UI form generation and data validation.
Agent test runner	A specialized testing framework (AgentTestRunner) that provides a sandboxed environment to execute agents and inspect resulting events. Essential for BDD testing with pytest-bdd.
Agent-in-the-loop	A pattern where one agent (orchestrator) invokes another agent (worker) and waits for its result. Enables complex workflows by composing smaller, specialized agents.
Context	State management system with two types: RunContext (ephemeral, single-run) and ThreadContext (persistent, cross-run). Used for maintaining state within and across agent executions.
Dispatchable workflow	The base class for all agents. Provides the infrastructure for event-driven step execution, event routing, and workflow orchestration.
Event	The atomic unit of communication in agent workflows. Pydantic models representing specific occurrences (e.g., UserMessageEvent, StopEvent, custom domain events).
Event flow	The sequence of events produced and consumed by agent steps. Visible in logs and Langfuse traces, crucial for debugging agent workflows.
Fan-out	A workflow pattern where a single step returns a list of events processed in parallel by downstream steps. Used for batch processing and concurrent operations.
Form duality pattern	A pattern where a single Pydantic model serves two purposes: Form Mode (fields contain FormkitElement instances for UI rendering) and Data Mode (fields contain primitive values). Enabled by the as_form() factory method.
Human-in-the-loop	A pattern where the workflow pauses to request input from a human user, emitting a request event and waiting for a response before continuing.
Precondition	A function decorated with @precondition() that must return True for a step to execute. Used for synchronizing parallel workflow branches and ensuring data availability.
Run context	Short-lived storage for ephemeral data within a single agent run. Isolated between runs, ideal for intermediate calculations and temporary caching. Expires after 30 days.
Step	A method decorated with @step() that represents a single operation in an agent workflow. Steps consume events as input and produce events as output, enabling clear workflow composition.
Step metadata	Rich information attached to steps via the @step() decorator, including localized names, descriptions, and icons for UI integration and monitoring.
Thread context	Persistent storage for state across multiple agent runs within the same conversation thread. Maintains conversational history and user preferences with 30-day TTL.
Trigger script	A Python script (trigger.py) that programmatically starts an agent, sends it a specific event, and terminates. Essential for focused debugging and testing specific scenarios.
Workflow	The fundamental design pattern for agents. A task broken down into a series of structured, explicit @step-decorated methods ensuring testability and transparency.

Process terms

Term	Definition
Agentic process	A dispatchable workflow that orchestrates high-level business processes through collaboration between agents, humans, and programs. The core abstraction that inherits from DispatchableWorkflow.
Process step	A method decorated with @process_step() that defines a single transformation and delegation point in a process. Steps consume work from one entity and delegate work to another.
Entity delegation	The pattern where process steps delegate work to specific entities (agents, humans, or programs) and wait for results. Core to the process orchestration model.
Entity delegator	Abstract base classes (Agent, Human, Program, Process) that define input/output configurations for work delegation to specific entity types.
Process configuration	A ProcessConfig object that defines process metadata including ID, name, and description for process identification and discovery.
Process runner	Production infrastructure (ProcessRunner) for running processes in live environments with NATS integration and event handling.
Process test runner	Testing infrastructure (ProcessTestRunner) that provides a sandboxed environment for testing processes with event observation and assertion capabilities.
Process discovery	System for discovering available processes and their input/output specifications through ProcessDiscoveryResponseEvent broadcasts.
Process dispatcher	Event dispatching system that routes work events to the appropriate process steps based on event types and delegation configurations.
Collaborative workflow	The fundamental design pattern where processes orchestrate work between different actor types (agents, humans, programs) rather than executing work directly.
Work transformation	The light data processing that occurs within process steps to transform the output of one entity into valid input for the next entity.
Process annotation	Metadata attached to process steps via the @process_step() decorator, including step names, descriptions, and entity delegation configurations.

Pipeline terms

Term	Definition
Asset	A Dagster concept representing a data object or file that is produced by a pipeline. Assets can be materialized (computed) and have dependencies on other assets.
Asset factory	A function that creates and configures Dagster assets with specific parameters, enabling reusable asset definitions across different pipeline configurations.
Dagster	The core orchestration framework used for building and managing data pipelines. Provides scheduling, monitoring, and dependency management capabilities.
Data lake file	A structured representation of a document stored in the data lake, containing content, metadata, and URI information for downstream processing.
Document parser	A resource that extracts text content and metadata from various document formats (PDF, Word, PowerPoint, etc.) using different parsing strategies.
Dynamic partitions	Dagster's mechanism for handling datasets where the partition keys are determined at runtime, allowing flexible processing of varying document sets.
Embedding model	AI model resource that converts text content into high-dimensional vector representations for semantic search and retrieval applications.
Graph asset	A Dagster asset composed of multiple operations (ops) that work together to transform input data into output data through a defined workflow.
I/O manager	Dagster resource responsible for storing and retrieving assets from specific storage systems (data lake, MongoDB, Milvus, etc.).
Job definition	A Dagster construct that defines a selection of assets to materialize, along with their execution configuration and resource requirements.
Language model	LLM resource used for generating summaries, descriptions, and other text-based processing tasks within the pipeline.
Node	A processed chunk of a document that has been parsed, embedded, and prepared for storage in a vector database for retrieval operations.
Observable asset	A Dagster asset that monitors external systems for changes and reports new partitions, triggering downstream processing when new data is available.
Operation (Op)	A Dagster concept representing a single unit of computation that takes inputs and produces outputs, forming the building blocks of pipeline workflows.
Partition	A subset of data that can be processed independently, typically representing individual documents or time-based slices of data.
Pipeline worker	A Dagster code location process that executes asset materializations. Workers connect to external services (Rclone, MinerU, LiteLLM, Milvus, SeaweedFS) and run outside Docker in the dev stage.
RefDoc	A reference document that serves as the authoritative source for a particular piece of content, stored in the document store with associated metadata.
Resource	A Dagster concept for managing external dependencies and configurations (databases, APIs, models) that are shared across multiple operations.
Run config	Configuration object that specifies how a particular pipeline run should be executed, including resource configurations and parameter values.
Sensor	A Dagster component that monitors external systems or schedules and triggers pipeline runs based on specific conditions or time intervals.
SharePoint file	A document retrieved from Microsoft SharePoint, containing raw content and metadata that serves as input for the data processing pipeline.
Summary node	A processed document chunk that contains summarized information, created using recursive summarization techniques for better context preservation.

API terms

Term	Definition
Controller	FastAPI router class that defines HTTP endpoints for a specific domain (e.g., AgentController, ThreadController). Controllers handle request/response logic and delegate business logic to Services.
Service	Business logic layer that processes requests from Controllers. Services interact with external systems (NATS, databases) and handle complex operations like agent discovery or thread management.
DTO (Data Transfer Object)	Pydantic models that define the structure of API requests and responses. DTOs provide validation, serialization, and documentation for API endpoints.
API runner	Infrastructure for starting and configuring the FastAPI application. Includes ApiRunner for production and ApiTestRunner for testing.
WebSocket manager	System for managing WebSocket connections, handling connection lifecycle, and routing messages between clients and the Swiss AI Hub backend.
Pagination	System for handling large datasets by splitting them into pages. Includes PageNumber, PageSize, and PaginatedResponse types.
Route mounting	Pattern for registering Controller endpoints with the FastAPI application. Controllers use fluent API to define and mount their routes.
Discovery service	System for finding and retrieving information about available agents, their capabilities, and current status.
Event streaming	Real-time communication system using WebSockets to stream events and updates to connected clients.
OpenAI compatibility	API endpoints that implement OpenAI-compatible interfaces for chat completions, embeddings, and other AI model interactions.
Simulated agent	Testing infrastructure that creates mock agents for API testing without requiring actual agent services.
Cache management	In-memory caching system (TTLCache) for reducing load on external services and improving API response times.

Bot integration terms

Term	Definition
Activity	Bot Framework concept representing any communication between bot and user (messages, typing indicators, conversation updates).
Activity handler	Base class from Bot Framework that processes different types of activities. All bots extend this class.
Agent chat bot	Bot implementation that connects to Swiss AI Hub agents, forwarding user messages to agents and streaming responses back.
Bot Framework	Microsoft's framework for building conversational AI applications, supporting multiple channels like Teams, Slack, etc.
Bot-in-the-loop	Pattern where a bot pauses an agent workflow to request human input via Slack, then resumes with the response.
Channel	Communication platform where the bot operates (e.g., Microsoft Teams, Slack, Web Chat).
Chat completion	Process of generating AI responses to user messages, supporting both streaming and non-streaming modes.
Completion handler	Abstract interface for processing chat completions, implemented differently for agents and OpenAI models.
Content extractor	Utility for extracting text and attachments from bot activities across different channels.
Conversation entity	Database model tracking conversation state, messages, and metadata with configurable TTL.
Conversation tracker	Service for persisting and managing conversation history across bot restarts.
OpenAI chat bot	Bot implementation that directly uses OpenAI-compatible models without agent orchestration.
Path entity	Database model storing conversation paths and routing information for multi-bot scenarios.
Routes service	Centralized service managing bot endpoint registration and channel configuration.
Simulated agent bot test runner	Testing infrastructure that mocks agent responses for development without real agents.
Slack utils	Utilities for handling Slack-specific formatting, threading, and user mentions.
Stream chat bot	Base class for bots that stream responses incrementally, providing real-time typing indicators.
Turn context	Bot Framework object containing all information about the current conversation turn.
Typing indicator	Visual feedback showing the bot is processing, with configurable timeout protection.

Web frontend terms

Term	Definition
Composable	Vue 3 composition functions that encapsulate and reuse stateful logic. In packages/web, composables manage API calls, state, and business logic using Pinia-Colada patterns.
Pinia-Colada	Advanced state management library that provides reactive queries, mutations, and caching for Vue applications. Used extensively for API state management in packages/web.
PrimeVue	Comprehensive UI component library providing rich, accessible components. Forms the foundation of packages/web's user interface with custom theming.
Nuxt layer	Nuxt 3 architectural pattern that allows sharing configuration, components, and composables. packages/web is structured as a reusable layer.
SPA mode	Single Page Application mode where the entire app runs client-side with no server-side rendering. Enables rich interactivity and real-time updates.
API proxy	Development-time proxy configuration that routes API calls from the frontend to the backend service, enabling seamless local development.
Socket.io integration	Real-time bidirectional communication system that enables live updates for chat, agent events, and system notifications.
Vue Flow	Workflow visualization library used for displaying agent workflows and process diagrams with interactive node-based interfaces.
ApexCharts	Charting library integration for displaying analytics, cost tracking, and performance metrics in dashboard components.
File-based routing	Nuxt 3 feature that automatically generates routes based on the file structure in the pages/ directory.
Auto-imports	Nuxt 3 feature that automatically imports composables, components, and utilities without explicit import statements.
Middleware	Functions that run before rendering pages, used for authentication, authorization, and route protection.
Generated SDK	TypeScript client automatically generated from the API's OpenAPI specification, providing type-safe API interactions.
Theme system	Custom PrimeVue theme configuration that provides consistent styling and dark mode support across the application.
Event display components	Specialized components for rendering different types of Swiss AI Hub events (LLM events, chunk events, exception events) with rich formatting.
Agent dashboard	Administrative interface for monitoring agent performance, managing configurations, and viewing agent-specific analytics.
Process visualization	Interactive workflow diagrams that show the flow of agentic processes with real-time status updates.
Evaluation interface	User interface for managing datasets, experiments, and AI model evaluations with results visualization.
Cost tracking	Dashboard components for monitoring and analyzing AI model usage costs with detailed breakdowns and trends.

Library and foundation terms

Term	Definition
Access checker	Core authorization component that evaluates user permissions against resources using hierarchical wildcards (*, >, ?*, ?>).
Auth handler	Abstract base class for authentication strategies. Implementations include OAuth2, Token, OpenWebUI, and Development-only handlers.
Base event	Foundation class for all events in the system. Provides automatic type registration, serialization, and metadata handling.
Base dispatcher	Core workflow execution engine that processes events through registered handlers in a stateless, distributed manner.
Configuration management	Pydantic-based system for managing service configurations with environment variable integration and validation.
Event store	Persistence layer for events, providing replay capabilities and audit trails using NATS JetStream.
Hierarchical permissions	Permission system using dot notation (e.g., aihub.user.agent.class.id) with wildcard support for flexible access control.
Identity provider	Strategy pattern implementation for user authentication supporting multiple backends (Azure AD, Token, Development).
Internationalization (i18n)	Multi-language support system with YAML-based translations and dynamic locale switching.
Locale handler	Core i18n component that manages language-specific content extraction and fallback mechanisms.
Locale string	Multi-language string representation supporting dynamic locale resolution and default fallbacks.
NATS integration	Message bus integration providing event publishing, subscription, and stream management for distributed communication.
Persistence layer	Database abstraction layer supporting multiple storage backends (MongoDB, Cosmos, Redis) with entity management.
Resource config	Pydantic models for configuring AI/ML services including LLMs, embeddings, and other generative AI resources.
Topic manager	NATS subject/topic routing system that manages message distribution across services and workflow components.
User identity	Core user representation including roles, permissions, and authentication state management.
Vector store	Abstraction for vector database operations supporting multiple backends (Milvus, Azure AI Search) for RAG implementations.

Architecture and infrastructure terms

Term	Definition
Dispatcher	The AgentDispatcher component that receives control events from JetStream, evaluates step readiness (whether a step's input event type has been published), checks idempotency (whether the step was already called with these events), and invokes the matching @step method.
Step store	A Valkey-backed data structure that tracks which steps have executed in a given run, with which input events, enabling idempotency checks and crash recovery.
Event persister	A NATS subscriber within the API process that writes every event to MongoDB for historical retrieval. Events are available through the REST API even if the WebSocket connection was interrupted.
Agent discovery	The mechanism by which the API discovers available agent classes. The API broadcasts a ClassDiscoveryRequestEvent every 60 seconds. Agents respond with AgentClassDiscoveryResponseEvent containing their event types, workflow graph, configuration schema, and profile templates. The API dynamically registers REST and SSE endpoints for discovered agents.
Config RPC	NATS request-reply on aihub.rpc.config.agent.{class}.{id} that fetches an agent profile's configuration. The API resolves the profile from MongoDB and responds with the merged configurable and non-configurable values.
Deep merge	The process of combining non-configurable field values (from as_form()) with user-submitted configurable values (from the Admin UI) to produce a complete AgentConfig in data mode.
LiteLLM	The LLM gateway that provides a unified OpenAI-compatible interface to all model providers (cloud and local). Handles model routing, token counting, cost tracking, and pre-call guardrail execution.
Presidio	Microsoft's PII detection framework, deployed as two microservices (analyzer and anonymizer). Integrated as LiteLLM pre-call guardrails for masking or blocking sensitive data before it reaches external LLM providers.
FerretDB	A MongoDB wire protocol proxy that stores data in PostgreSQL. Provides MongoDB-compatible queries without the SSPL license. Used for conversation threads, agent events, application metadata, and process state.
Valkey	A Redis-compatible in-memory data store (BSD-licensed fork). Used for ephemeral agent state (step tracking, run context, thread context) and role-based rate limiting.
SeaweedFS	An S3-compatible distributed object store deployed as four containers (master, volume server, filer, S3 gateway). Stores uploaded files, pipeline artifacts, Milvus data segments, and Langfuse trace artifacts.
JetStream	NATS's built-in persistence layer for durable message delivery. Control events are published to JetStream streams, enabling event replay after agent crashes and guaranteed at-least-once delivery.
NATS Core	The ephemeral pub/sub layer of NATS. Display events and streaming chunks are published to NATS Core for real-time delivery without persistence overhead.

Deployment terms

Term	Definition
Deployment stage	One of five environment configurations (dev, local, build, nightly, latest) that determine which services are included, how TLS is configured, and where container images come from.
Volume root	The host directory (default .docker-volumes/) where all stateful services store persistent data via bind mounts. Backing up this directory captures all platform data.
Proxy network	The Docker network carrying external ingress traffic via Traefik. Services reachable from outside attach to this network.
Backend network	The Docker network connecting application services (agents, LiteLLM, inference servers, Presidio). Not directly reachable from outside in non-dev stages.
Data network	The Docker network connecting databases, caches, and the message broker (PostgreSQL, FerretDB, Milvus, Neo4j, NATS, Valkey, ClickHouse, etcd).
Storage network	The Docker network connecting the SeaweedFS cluster and services that access object storage.
Egress network	The Docker network providing outbound internet access with inter-container communication disabled. Only Playwright attaches to this network.
Init container	A container that runs once at startup (restart: no) to perform idempotent initialization (creating database schemas, S3 buckets, default roles). Downstream services use service_completed_successfully to wait for init containers.

Security terms

Term	Definition
Access rule	A dotted-path string that grants permission to a resource. Follows the pattern aihub.[user|admin].<resource>.<subresource>.<id>, where * matches one segment and > matches one or more trailing segments.
Handler chain	The authentication pattern where TokenAndOauth2Handler tries multiple AuthHandler implementations in sequence (OAuth2, API token, OpenWebUI HMAC, superuser) until one succeeds.
Superuser token	A global authentication token (SUPERUSER_TOKEN environment variable) that bypasses RBAC. Used internally by the LangfuseProvisioner and for deployments without an identity provider.
Guardrail	A LiteLLM pre-call hook that intercepts LLM requests for policy enforcement. The platform defines two Presidio-based guardrails: presidio-mask-guard (replaces PII with tokens) and presidio-block-guard (rejects requests containing sensitive data).

Observability terms

Term	Definition
SmartTracer	A wrapper around the OpenTelemetry tracer that adds @trace_fn (automatic parameter and return value capture) and @no_trace (trace suppression for health checks and internal operations).
Trace context propagation	The mechanism that links spans across NATS message boundaries using W3C Trace Context headers. NATSTraceContextPropagator injects and extracts span context from NATS message headers.
OTEL Collector	The central telemetry hub that receives traces via OTLP and routes them through processing pipelines: a noise filter (drops health checks, database client spans) and a Langfuse filter (selects semantic AI events for cost and quality tracking).
Langfuse	The AI observability platform (MIT-licensed, self-hosted) that provides prompt/response capture, per-trace cost attribution, RAG retrieval tracing, and evaluation datasets. Replaced Arize Phoenix due to licensing incompatibility.
OpenInference	A semantic convention for AI observability spans. Semantic events implement to_semantic_convention() to produce OpenInference-compatible attributes, enabling Langfuse to interpret LLM calls, retrieval operations, and guard evaluations.