Glossary

Railtracks uses a handful of ordinary words in a specific way. Each entry below says what a term means in one or two sentences, then links to the page that describes it in full.

Contributing to this page

Entries here are pointers, not documentation: at most two sentences, always ending in a link, and no code or examples. If a term needs more than that to make sense, the linked section is too thin, so expand that section rather than this page.

Building Blocks

Harness

The code around a model call: the loop that keeps calling it, the tools it can reach, what lands in its context, the limits on what it may do, and the record of what it did. Railtracks builds each of those parts from ordinary Python objects you assemble yourself. Agent Harness

Agent

A system that pursues a goal on its own, deciding what to do next rather than following a fixed script. In Railtracks an agent is built as an agent node. What is an Agent?

Node

The unit Railtracks executes: it accepts inputs, runs, and returns an output. Agents, tools, and plain Python functions are all nodes, which is what lets Railtracks treat them interchangeably. Building Blocks

Agent Node

A node whose work is a call to an LLM, built with rt.agent_node() and holding the model, system message and available tools. Reach for one when the step needs judgement rather than a fixed implementation. Building Blocks

Function Node

One of your own Python functions turned into a node by the @rt.function_node decorator. It is how deterministic work enters a graph, and how a function becomes a tool an agent can call. Function Tools

System Message

The instructions an agent is configured with through system_message=, which Railtracks sends first on every call to that agent. A system message placed in a message history instead belongs to the conversation and stays where the caller put it. System Messages

Tool

A capability an agent may choose to invoke, letting it act on the world instead of only producing text. In Railtracks a tool is any node passed to an agent as tool_nodes=. What Is a Tool?

Tool Manifest

The description an agent carries of how other agents may call it, given as manifest=rt.ToolManifest(...). It sets the description and parameters other agents see, in place of the ones generated from the agent's system message. Agents as Tools

LLM

The language model an agent calls, configured through rt.llm.* and chosen per agent with llm=. See LLMs as Agents for the concept and Providers for the models Railtracks can reach.

Structured Output

A response validated against a schema you supply as output_schema=, so an agent returns typed data rather than a string you have to parse. Structured Output

Middleware

A layer that wraps a call to add behaviour around it, such as retries, logging or redaction, without changing the thing being called. Several can be attached to the same target, where they run as nested layers. Middleware

Node Middleware

Middleware that wraps an entire node invocation, attached with middleware= on any node. Node Middleware

Model Middleware

Middleware that wraps a single model call rather than the whole node, attached with model_middleware=. It applies only to agent nodes, since a function node never calls a model. Model Middleware

Guardrail

Model middleware that inspects what goes into or comes out of a model call and decides whether to allow, change or reject it. Also referred to as a guard or a rail. Guardrails

Verifier

Node middleware that gates a call on a decision made outside the graph, which is how human-in-the-loop (HIL) review is built in Railtracks. Verifiers

Coupling

Attaching middleware to an existing node with rt.couple(), which returns a new node class rather than modifying the original. Attaching Middleware

MCP

The Model Context Protocol, an open standard for exposing tools to models. Railtracks can both consume MCP tools and expose its own nodes as an MCP server. Model Context Protocol

Running Agents

Flow

A named, reusable entry point for an agent graph, binding one entry point node to a fixed set of runtime options. It is the intended top level of a Railtracks program. Flows

Entry Point

The node a Flow starts from, given as entry_point=; every other node in the graph is reached from it. Entry Point

Run

One execution of a Flow, started by invoke or ainvoke. It is the scope for context, timeouts and per-run budgets, and no two runs share state. Run

Direct Invocation

Calling a node yourself with await rt.call(...) instead of letting an agent decide to call it. It is how the steps inside a Flow are composed. Direct Invocation

Message History

The conversation an agent saw and produced, returned on every agent response as response.message_history. Calls are stateless, so passing that history back is how a conversation continues across calls. Message History

Context

Key-value state that any node in a run can read and write, used to pass data between agents without threading it through their messages. It lives only for the length of the run. Global Context

Session

The record Railtracks writes for a run, stored under .railtracks/data/sessions/ and read back by the visualizer and the evaluation tools. Prefer run when referring to the execution itself. Local Visualization

Broadcasting

Sending live updates out of a running graph to a callback, so progress can be surfaced while the run is still going. Broadcasting

Streaming

Receiving a model's tokens as they are produced rather than waiting for the finished response, via rt.astream. Streaming

Architectures

Sequential Flow

A Flow whose steps run in the order your Python code awaits them, rather than in an order a model chooses. Sequential Flows

Validation Loop

An architecture in which an agent evaluates its own output, applies the feedback and tries again until the result meets a bar. Validation Loops

Agent as Tool

Giving one agent another agent as a tool, so the caller delegates a sub-task instead of handling it itself. Agents as Tools

Evaluation

Evaluator

The component that runs an evaluation over a dataset and produces structured results. Evaluators

Metric

What an evaluation measures, either a category or a number, supplied to or fixed by an evaluator. Metrics

Retrieval

Document

A loaded source file together with its metadata, before it has been split. The Document object

Chunk

A slice of a Document sized for embedding and retrieval. The Chunk object

EmbeddedChunk

A Chunk together with the vector produced for it. The EmbeddedChunk object

Store

The backend that holds embedded chunks and answers similarity queries against them. Data models

Retrieval Runtime

The object that ties loading, chunking, embedding and storage into one pipeline you can ingest into and query. Retrieval Quickstart