Glossary

An autonomous software entity that uses a foundation model to reason, plan, and execute tasks by invoking tools and skills in a loop until a goal is met.

A centralized or federated catalog where agents and their capabilities are published, discovered, and versioned — enabling reuse and coordination across teams.

A prompting technique that instructs the model to produce intermediate reasoning steps before arriving at a final answer, improving accuracy on complex tasks.

A non-professional developer (e.g., product manager, analyst) who builds automations or skills using low-code tools and agentic frameworks without deep software engineering expertise.

The practice of combining smaller, single-purpose skills or agents into larger workflows — favoring reuse and modularity over monolithic implementations.

External parameters (model choice, temperature, tool allowlists, guardrails) that control agent behavior without modifying core logic or prompt text.

The maximum number of tokens a foundation model can process in a single request — encompassing the system prompt, conversation history, tool results, and the generated response.

The essential reasoning and orchestration code within an agent or skill that determines how inputs are processed and actions are selected — distinct from configuration and tool integrations.

A design pattern where external services (tools, APIs, data stores) are provided to a skill at runtime rather than hard-coded, improving testability and portability.

A structured approach for measuring agent or skill quality — including test scenarios, success criteria, latency benchmarks, and regression detection — enabling continuous improvement.

A governance model where a central team sets standards, guardrails, and review processes while individual teams retain autonomy to build and publish their own skills and agents.

A large language model (LLM) or multimodal model pre-trained on broad data that serves as the reasoning engine for agents — e.g., Claude, GPT, Llama.

Constraints applied to agent behavior to ensure safety, compliance, and correctness — including input validation, output filtering, tool restrictions, and human-in-the-loop approvals.

A mechanism in skill or agent configuration files that pulls in external resources (other skills, context documents, tool definitions) by reference rather than inline duplication.

A formal definition of a skill's inputs, outputs, and side effects — enabling type-safe composition, validation, and documentation generation.

A curated collection of documents, facts, or embeddings that an agent can query (via RAG or direct lookup) to ground its responses in verified information.

A centralized service that routes agent requests to foundation models while enforcing rate limits, access control, logging, cost tracking, and model version management.

A standardized protocol for connecting agents to external tools and data sources — providing a uniform interface for tool discovery, invocation, and result handling across heterogeneous backends.

Descriptive information attached to a skill or agent (name, version, author, description, tags, dependencies) that enables discovery, governance, and dependency resolution.

An anti-pattern where a single skill file handles too many responsibilities — making it hard to test, reuse, or maintain. Contrast with the Single Responsibility Principle.

Patterns for multiple agents to collaborate on a task — including delegation, fan-out/fan-in, pipeline handoffs, and shared context — while avoiding conflicts and duplication.

A technique where repeated or static portions of a prompt (system instructions, skill definitions) are cached by the model provider to reduce latency and cost on subsequent calls.

A pattern where relevant documents are retrieved from a knowledge base and injected into the model's context before generation — grounding responses in factual, up-to-date information.

An agent architecture that interleaves Reasoning (chain-of-thought) with Action (tool calls), observing results before deciding the next step — enabling iterative problem-solving.

A self-improvement pattern where an agent reviews its own output, identifies errors or shortcomings, and retries with corrective feedback — closing the loop without human intervention.

The gradual expansion of a skill's responsibilities beyond its original purpose — leading to monolithic designs, increased complexity, and reduced reusability.

A versioning scheme (MAJOR.MINOR.PATCH) applied to skills and agents where breaking changes increment MAJOR, new features increment MINOR, and bug fixes increment PATCH.

Unsanctioned use of AI tools or agents within an organization — operating outside governance, security review, and compliance controls — creating risk and duplication.

The design guideline that each skill should do one thing well — with a clear, bounded scope — making it easier to test, version, compose, and replace.

A structured document (typically markdown with front matter) that defines a skill's trigger, steps, rules, and resources — serving as both documentation and executable specification for an agent.

A shared repository of vetted, versioned skills that teams can discover, import, and compose into their agents — reducing duplication and raising quality through reuse.

Techniques for reducing token consumption (and thus cost and latency) — including concise prompts, context pruning, caching, summarization, and selective tool-result inclusion.

An intermediary layer that brokers agent requests to external tools — handling authentication, rate limiting, error retries, and audit logging in one place.

A defined sequence or graph of steps — potentially spanning multiple skills and agents — that accomplishes a complex task, with explicit control flow, error handling, and completion criteria.