Concepts

An open protocol for communication between independent AI agents - discovery via a published Agent Card, work delegated as a stateful Task, updates streamed or pushed back.

A system that uses a language model to plan, execute tool calls and iterate towards a goal, rather than producing a single response.

The execution system that wraps a model and turns it into a working agent - owning the agent loop, conversation state, the permission policy, the sandbox and recovery across turns.

The problem of making a model behave according to intended values and instructions, rather than pursuing the training objective in unintended ways.

Systems that perform tasks normally requiring human cognition, from classification and generation to planning and tool use.

A mechanism that lets each position in a sequence attend to every other position, weighting their relevance dynamically rather than relying on fixed-distance connections.

A long conversation or agent trace is summarised and the window restarted from the summary, so the loop can continue past the context limit.

The fixed number of tokens a model can attend to on one request, shared between the system prompt, tools, retrieved documents, history and the answer itself.

Machine learning with neural networks of many layers, which learn hierarchical representations from raw data rather than hand-engineered features.

Splitting the prefill and decode phases of an inference request onto different workers, so each runs on hardware suited to its own bottleneck.

Training a smaller student model to reproduce the outputs of a larger teacher model, transferring capability at lower inference cost.

A fixed-length vector that represents the meaning of a piece of text, image or other input, positioned so that similar items are nearby in the vector space.

Structured tests for an LLM system: a fixed input, a run, and grading logic applied to the output, where the grader may be a rule, a rubric, a reference answer, a second model or a person.

Continuing training on a narrower dataset to specialise a pretrained model for a particular task or domain.

A model generates text that is fluent and confident but factually wrong, because it is optimised for plausibility rather than truth.

Running a trained model to produce output, as distinct from training it. The phase where cost, latency and throughput matter operationally.

The cached key and value tensors from a prompt's attention computation, kept so that generating each next token does not recompute the whole prefix.

Using a language model as the grader in an evaluation: it reads an output, applies a rubric or compares against a reference, and returns a score or verdict.

A system improves at a task by learning from data rather than being explicitly programmed for it.

An open wire protocol that standardises how an application hosting a language model discovers and calls external capabilities - tools, resources and prompts - exposed by servers.

Models that process and generate across multiple modalities - text, image, audio, video - rather than text alone.

A computation graph of weighted connections between nodes, where the weights are adjusted during training to approximate a target function.

A learned weight in a model, adjusted during training. Parameter count is the headline measure of model size.

Loading information into context in stages rather than all at once - metadata always, instructions on trigger, resources on demand - so an agent pays the token cost only for what a task actually uses.

Reducing the numerical precision of model weights (for example from 16-bit to 4-bit) to lower memory requirements and speed up inference.

A model generating intermediate steps or chains of thought before arriving at an answer, trading latency for accuracy on complex problems.

An agent learns by trial and reward, maximising a cumulative signal rather than matching labelled examples.

Relevant documents are retrieved at query time and supplied as context, so the model answers from evidence rather than parametric memory.

The boundary a code-execution sandbox puts between model-generated code and the host - ranging from a shared process with no boundary at all to a dedicated host that shares nothing.

Training data generated by a model rather than collected from real-world sources, used to augment datasets or avoid privacy constraints.

The atomic unit a language model reads and generates - a word, subword, or byte depending on the tokeniser.

A model emits a structured request to invoke an external function, and the result is returned as context for its next step.

The process of adjusting a model's parameters by iterating over data, producing the weights that define the model's behaviour.

An architecture that processes input in parallel using self-attention, replacing recurrence and enabling training on much larger datasets.

A store optimised for indexing and querying high-dimensional vectors, used to find semantically similar items for RAG and other retrieval tasks.

Text or images are embedded as vectors and compared by distance, so results are ranked by similarity rather than keyword match.

An agent holds more functionality, permissions, or autonomy than its task requires, so a compromise becomes an incident.

Crafted input changes model behaviour, because a language model makes no architectural distinction between instructions and data.

Dead row versions left by MVCC occupy space until a background process reclaims them; if it falls behind, tables and indexes grow without the data growing.

A constraint that links a column in one table to the primary key of another, enforcing referential integrity so that orphan rows cannot exist.

A data structure maintained alongside a table that makes lookups by specific columns faster, at the cost of slower writes and additional storage.

The contract for which concurrency anomalies a transaction may observe, traded against how much concurrency the engine allows.

Readers see a consistent snapshot without blocking writers, because an update creates a new row version rather than overwriting the old one.

Organising tables so that each fact is stored once, reducing redundancy at the cost of more joins.

A column or set of columns that uniquely identifies every row in a table, enforced by a unique index and a NOT NULL constraint.

The delay between a write committing on the primary and becoming visible on a replica.

The structure that defines how data is organised in a database: tables, columns, data types, constraints, relationships, and indexes.

The field determining which shard a document lives on, and therefore which queries can be routed to one shard rather than all of them.

A named block of SQL (or procedural code) stored in the database and executed on the server, avoiding the round-trip cost of sending each statement from the application.

A sequence of operations that either all succeed (commit) or all fail (rollback), guaranteeing that the database moves from one consistent state to another.

PostgreSQL transaction IDs are 32-bit and wrap around, so rows must be frozen before the counter laps them or data would appear to vanish.

Code that the database executes automatically when a specific event occurs on a table - typically an INSERT, UPDATE, or DELETE.

A named query stored in the database that behaves like a virtual table - it does not hold data itself but runs its defining query each time it is read.

One logical write causes several physical writes - to the log, the data pages, and every affected index.

A saturated component signals upstream to slow down, rather than accepting work it cannot complete.

An algorithm by which unreliable nodes agree on a single ordered history, usually Raft or Paxos in practice.

Replicas converge on the same state given no further writes, but may disagree at any given moment.

Positively preventing a demoted or unreachable node from continuing to serve, rather than assuming it has stopped.

A majority of members must agree before a decision stands, which is what stops two halves of a partitioned cluster both acting as leader.

Two nodes both believe they are primary, usually after a network partition, and both accept writes that cannot afterwards be reconciled.

Many client connections share a smaller set of server connections, because a database connection is expensive and mostly idle.

The number of distinct time series a metric produces, which is the product of every label's distinct values.

A component is granted only the permissions its task requires, so that compromising it yields as little as possible.