Autonomous AI Systems Glossary

.antigravityignore

This is the physical blacklist file that stops the agent from getting lost in giant libraries like `node_modules` while working across the file system and suffering a Segmentation Fault (memory overflow).

It works on the same logic as a traditional `.gitignore` file; but where `.gitignore` only ignores changes on the git side, `.antigravityignore` directly protects the agent's working area and the Context Window boundaries. It ensures agents in Agentic IDE (Antigravity IDE, etc.) environments only move around within the Workspace Rules you've allowed, which both boosts speed and prevents wasted tokens.

60/30/10 Rule

This is an Agentic Engineering principle used to optimize resource and budget management across agent ecosystems. Instead of processing every task in the system with equal weight, it splits work into 3 main categories:
- 10% (Complex): Top-tier Deep Reasoning models are used for tough tasks that need architectural decisions and deep Reasoning.
- 30% (Medium): Standard models are used for routine work like data processing or drafting.
- 60% (Simple): Low-cost models (Fast Mode) are preferred for simple jobs like code formatting or routing.
This rule balances intelligence against Token Burn Rate.

A2A (Agent-to-Agent)

This is the communication protocol where agents talk to each other directly (P2P) without waiting for human (HITL) approval or going through a central Orchestrator. Unlike centralized structures, it lets every agent in a Multi-Agent System share data autonomously with the others.

For example, when an Implementer Agent hits an error, instead of reporting the problem to the main conductor, it contacts the Resolver Agent directly. During this exchange, Identity Propagation keeps permissions intact end to end.

ACL (Access Control List)

This is the hardware-level security barrier that restricts agents and sub-components like Sidecars from freely reaching the operating system's files, folders, and network resources. Agent security is handled in 3 layers:
- At the high level, Guardrails (prompt boundaries)
- At the communication level, MCP restrictions
- At the hardware and system level, the ACL.
ACL rules designed on the Principle of Least Privilege make sure that even if a malicious Prompt Injection attack succeeds, the agent is still flatly blocked from deleting critical system files.

ACT

This is the "apply and trigger" stage where autonomous AI doesn't just think, but makes physical or digital changes out in the real world.

It's one of the 4 core phases of the Agentic Loop cycle, turning the decisions made during Observe and Reasoning into concrete action.

At the moment of action, the agent uses Tools — its hands — to write a record to a database, create a file, or trigger an API.

Adversary Agent

This is a cybersecurity ("Red Teaming") agent tasked with attacking your own system in order to test the resilience of autonomous systems. Unlike constructive (generative) agents such as the Orchestrator or a Worker Agent, it plays a simulated attacker role focused on finding the system's boundaries and security holes.

Its job is to push against Guardrails mechanisms, try to force agents past their boundaries with Prompt Injection attacks, and report every vulnerability before the system goes live.

Agent OS

This is the intelligent orchestration layer that manages the memory, hardware resources, and task queues of hundreds of autonomous agents in the background — much like a Windows or Linux kernel.

It sits above Agentic AI structures, which focus on the individual operations of a single agent. It controls agents' Principle of Least Privilege rights, kicks off Self-Correction (automatic recovery) when something crashes, and provides a secure hosting service for A2A communication between agents.

Agent Routing

This is the process of analyzing a complex request coming from a user or the system and autonomously routing it to the right specialist Worker Agent unit. It reads the intent of the request using Semantic Routing instead of traditional if/else blocks.

It's run by the central Orchestrator. For example, a request that needs a database query gets sent straight to the SQL specialist agent, while a design change is assigned to the CSS specialist agent.

Agent Skills

These are expertise (know-how) packages that go beyond just giving the agent a list of Tools, and instead explain "how and in what order" to actually use that tool in the real world. They're usually documented in SKILL.md format.

They deliver not just code but an institutional way of working. By teaching agents not only what to do (System Prompt) but how to do it (Procedural Memory), they guarantee deterministic, predictable results.

Agentic AI

These are autonomous AI systems that take just the end goal from you, build their own plan behind the scenes, correct themselves when they make a mistake (Self-Correction), and act using tools.

Unlike passive chatbots such as ChatGPT, it analyzes the problem with Reasoning, builds a Plan, and actually does and completes the work within the Agentic Loop cycle.

Thanks to its Orchestration ability, it can coordinate multiple specialist Worker Agent units.

Agentic Engineering

This is the discipline of building autonomous architectures — with mathematical Agentic Loop designs, rigorous Evals (tests), and impenetrable Guardrails firewalls — in place of fragile, luck-based, primitive coding practices (Vibe Coding).

It's the art of building production-ready, enterprise-grade multi-agent systems that don't crash in the face of errors, but instead push forward by resolving their own mistakes through Self-Correction.

Agentic Loop

This is the endless spiral life cycle at the heart of an autonomous system, iterating on itself until it reaches the goal. It makes the agent follow these 4 phases at every step:
- Discover/Observe: Observing and analyzing the environment.
- Plan: Planning the steps to take.
- Reason: Internal reasoning and decision-making.
- Execute/Act: Taking action in the outside world.
Unlike classic code flows, this cycle is dynamic — when it hits an error it loops back to the start and develops new strategies using Loop Engineering principles.

Agentic RAG

This is an autonomous data-retrieval loop that works actively, like a detective, instead of the static RAG (Retrieval-Augmented Generation) approach that blindly accepts whatever's pulled from a Vector Database.

The agent tests the accuracy of the data it finds with State Verification, and if it finds something missing, it kicks off a new search with different keywords on its own. The goal is to raise Grounding quality and drive Hallucination risk down to zero.

Agentic IDE

This is an integrated development environment where agents work shoulder to shoulder with developers, given full powers like writing code, Terminal access, reading files, and MCP Client integration (e.g., Cursor, Antigravity IDE).

Unlike browser-based chatbots, they run Plan and Execute cycles autonomously, directly inside your project, on your local files (within the allowed ACL boundaries).

AGI (Artificial General Intelligence)

This is the hypothetical level of super-intelligence that goes beyond today's Narrow AI systems — which specialize in specific domains like writing code or translation — and can teach itself to do any cognitive, creative, or analytical task a human could do.

Agent systems, which combine different Worker Agent specialties under a single Orchestrator, are regarded as some of the most important building blocks on the road to AGI.

Always Proceed

This is an aggressive permission setting that lets the agent keep going autonomously — without asking a human for HITL approval — when it's about to run commands that could be risky or change the system (e.g., deleting a database, running terminal code).

While it speeds things up inside Autonomous Mode, when it isn't backed by Guardrails it can create serious risks to system security.

Antigravity

This is an advanced agent command center that lets hundreds of AI agents be coordinated like a massive enterprise software team.

By housing Antigravity CLI (the Terminal tool), Antigravity SDK (the software library), and Antigravity IDE (the development environment), it lets developers manage and supervise autonomous processes end to end and build a fully integrated Multi-Agent System.

Antigravity 2.0

This is the next-generation desktop version of the Antigravity platform, with a graphical interface (GUI) that goes beyond the classic terminal (CLI).

It visualizes the complex output agents produce in interactive Artifacts panels, lets you watch the Subagent hierarchy live on a graph, and lets you visually step into the Chain of Thought (thinking stages). It's a professional control center where the Orchestrator and its sub-agents are managed with the ease of drag-and-drop.

Antigravity CLI (agy)

This is a lightweight, text-based agent controller with no graphical interface (GUI), built to run directly inside SSH sessions or IDE terminals for developers.

It consumes almost zero RAM and processor resources. Working on TUI (Terminal UI) logic, it's a fast, minimalist tool that lets you assign autonomous tasks to background agents, list their status, and manage system Daemon processes.

Antigravity SDK

This is the core architectural library that lets developers build their own custom autonomous agents in Python or TypeScript, add new Tools to the system, and write OS-level JSON Hooks triggers.

Where Antigravity CLI manages things externally through commands, the SDK gets embedded directly into your application's codebase, letting you build your own Agent OS infrastructure.

Antigravity IDE

This is a modern development environment purpose-built for writing code, reviewing, and running processes together with agents, combining Terminal, MCP Client, and autonomous system components under one roof.

Unlike an ordinary editor, while you're writing code, it lets agents with Agentic AI abilities access your file system and work with you in an asynchronous, A2A-style sync (peer-programming).

API

This is the traditional data interface where different pieces of software and servers talk to each other with fixed rules (endpoint, request, response).

Unlike fixed, static classic API connections, the dynamic and flexible MCP (Model Context Protocol) lets AI autonomously discover tools and resources.

In older systems, the agent needs an API Connector bridge to be able to talk to an API at all.

API Connector

These are classic translator (bridge) plugins that let an agent talk to the outside world on legacy closed systems (e.g., Salesforce, legacy ERPs) that don't directly support the modern MCP (Model Context Protocol) architecture.

They give agents flexibility by translating the complex XML or JSON data an API returns into a simple Tools capability the agent can easily understand and process (e.g., a `fetch_user_data` function).

Artifacts

These are the outputs an agent produces after long, complex operations, presented not as boring plain text but in a human-readable, visual (structured) format — an Implementation Plan, a UML diagram, a table, or a Markdown report.

This approach makes human observation easier and lets the developer quickly approve (HITL) the system's decisions and keep the process moving.

BigQuery

This is a massive data-analysis engine running on the Google Cloud platform that can query billions of rows of data in seconds.

Autonomous agents can export Google Analytics (GA4) data into BigQuery and run deep analysis with SQL queries. In Agentic RAG workflows, it's a powerful Tools resource that turns raw data into meaningful insight.

Browser Sub-Agent (/browser)

This is a visual sub-agent (Subagent) coded specifically for web interface testing. It connects to a browser autonomously through Chrome DevTools and clicks buttons and fills out forms like a human.

While running UI Testing, it autonomously records video (WebM) to prove any errors it hits, and reports the status back to the top-level Orchestrator along with the evidence.

Budget Guardrails

These are hardware-level safety fuses that stop an agent from falling into an infinite loop because of an unexpected error and blowing up costs in seconds with a flood of API requests.

They include Cost Control Limits. Standard Guardrails are usually about security and access (read/write), while Budget Guardrails are entirely about policing the agent's Token Burn Rate limits and hard-stopping the system in an emergency when needed.

Campaign Syncing

This is the process of agents autonomously syncing marketing campaigns (Google Ads, Meta Ads, etc.) with external platforms using an API Connector.

It replaces manual copy-paste work. The agent updates the ad copy out on the external platform during the ACT stage, based on rules or budget strategies that change in the database (e.g., Firestore).

CDN (Content Delivery Network)

This is speed infrastructure that distributes a website's static files (images, CSS, JavaScript) across servers worldwide, serving each user from the closest point (e.g., Cloudflare, AWS CloudFront).

It directly affects Core Web Vitals and PageSpeed / Lighthouse scores. Autonomous agents can suggest CDN configuration changes based on the results of speed tests.

Centralized Agent Networks

This is the model in a multi-agent architecture (MAS) where the network is managed strictly and hierarchically by a single central "dictator" agent in the Conductor role.

It's a structure where lower-level Worker Agent units don't make autonomous decisions on their own, only carrying out the Task Plan steps they're ordered to. It runs slower than the Decentralized Agent Networks model, but it's safer for enterprise Governance and auditing.

Chain of Thought (CoT)

This is when an LLM, instead of jumping straight to a conclusion and making a mistake (Hallucination) while solving a complex problem, "thinks out loud" — in speech or text — by breaking the problem into steps (e.g., "Step 1: find x, Step 2: multiply by y").

It's the core strength of advanced Deep Reasoning models. It lets the agent convince itself and reach error-free conclusions by following a logical order during the Reasoning stage.

Chat Room Debate

These are multi-agent autonomous decision-making sessions where agents form Debate Loops and clash ideas from different perspectives, much like a WhatsApp group.

Typically an Implementer, a Reviewer, and a Contrarian Agent are put in the same room (Context Window). This keeps the system from blindly accepting the first solution it finds, and instead lets it reach the right decision through consensus.

Chatbot

This is an automated chat assistant on websites, usually rule-based (if/else) or backed by simple AI, that answers visitors' questions.

The difference from Agentic AI systems is that it can't step outside predefined scenarios, can't use Tools, and can't make autonomous decisions. Modern agentic systems are equipped with Reasoning and Self-Correction abilities that go far beyond a chatbot.

ChatGPT

This is the AI assistant built by OpenAI that millions of people use directly through conversation. Its core difference from Agentic AI systems is that it can't run an autonomous cycle (Agentic Loop) and can't physically intervene in the outside world with Tools.

ChatGPT is a passive chatbot; but in agentic systems like Antigravity IDE, that same LLM brain turns into an active machine that runs autonomously through ACT and Observe cycles.

ChatSessionStore.index

This is the local JSON index database that links an agent's old chat sessions to the project's State Management history, especially in Agentic IDE (Antigravity, etc.) systems.

It's not a temporary Working Memory file; it's a sensitive, critical-to-back-up file that, when it gets corrupted or throws a read error, makes an agent's past (Long-Term Memory) experience unreachable (Context Rot).

Claude (Anthropic)

This is the AI model family (Claude Sonnet, Opus, etc.) built by Anthropic, focused on safety and harmlessness. It's a direct rival to OpenAI's GPT series.

Thanks to its long Context Window capacity (200K+ tokens), it can analyze massive codebases in a single pass. In Agentic IDE ecosystems, it's used as an alternative brain for Orchestrator or Deep Reasoning tasks.

Clean Architecture

This is the standard where software is designed in layers (Domain, Use Cases, Interfaces), fully isolated from external dependencies (UI, Database, Framework).

When agents write code, they check Clean Architecture rules against Semantic Memory stored in SKILL.md documents to prevent Technical Debt from building up. Enterprise agents take these rules as a template so they don't produce spaghetti code.

Client (MCP)

In the new-generation MCP (Model Context Protocol) architecture, this is the bridge (communication) layer that runs directly inside the application (Host) and lets the model talk to the MCP Server on the other end.

It autonomously discovers the tools the server offers through Capability Negotiation, and plays the role of go-between by translating the model's simple JSON requests into the standard JSON-RPC commands the server understands.

Cloud Functions

These are small pieces of code that run automatically when a specific event fires (a Trigger), without needing any server management (e.g., AWS Lambda, Google Cloud Functions).

They run background tasks triggered by autonomous agents via a Webhook or JSON Hooks cheaply and at scale. They're the building block of Serverless architecture.

CLI (Command Line Interface)

Without a graphical interface (GUI), this is the fast communication layer where agents manage a server, a local machine, or an application directly with text-based commands (bash/PowerShell).

It's the most natural interface for agents. Compared to Vision-based interfaces that have to interpret pixels, it consumes far fewer Tokens and improves the system's Structured Output quality by getting results back deterministically (`--json`).

CLI Tools

This is the group of low-level tools (Tools) that let an agent intervene directly at the operating system's Terminal command line (CLI).

For example, it covers capabilities like `npm install`, `git commit`, or `mkdir`. Because it grants direct write access to the system, using it without isolation behind nsjail (Sandbox) or a strong ACL barrier is very risky from a security standpoint.

CMS (Content Management System)

This is a platform that lets you manage a website's content (posts, pages, media) without needing technical knowledge. WordPress, Webflow, and Wix are the most common examples.

Autonomous agents can connect to CMS systems through an MCP Server to autonomously handle content creation, SEO optimization, and page updates.

Compound AI System

This is a "compound" architectural approach made up of a chain of multiple small/specialist models, an external Vector Database, and dynamic Tools, instead of loading all the work onto a single giant (and expensive) model the way traditional systems do.

The agent itself isn't a single brain; instead, it solves complex problems as an autonomous whole by using a Compound AI System (RAG + Model + Python Engine).

Conductor

This is the strategic manager sitting at the very top of the Orchestrator-Worker hierarchy. It doesn't waste time writing code directly (ACT) or connecting to databases.

Its job is to break a big incoming request (e.g., "Refresh the site") into pieces (Plan), distribute tasks to the Worker Agent units below it, and combine their sub-outputs to approve the final product. In the Maker-Checker Architecture model, it takes on the "Checker" role.

Context Engineering

This is the art of going beyond just using magic words for Prompt Engineering to boost system quality, and instead designing exactly which specific, clean, up-to-date RAG data gets placed in front of an agent at runtime.

The focus is on trimming away unnecessary data (Context Pruning) to protect the agent's Token Burn Rate limits and prevent Lost in the Middle syndrome.

Context Rot

This is when an agent forgets the actual topic (task) at hand because its memory space (Context Window) has piled up with massive, irrelevant code files and repetitive, long error logs (Observe).

As a result of this memory poisoning, the agent becomes paralyzed, its response time slows, and it slides into Hallucination (making things up), crashing the system. The fix is to regularly summarize the history and clear out the Working Memory (short-term memory) space.

Context Wall

This is a data-filtering system set up in large software projects to keep lower-level Worker Agent units from getting crushed under the entire project's massive data (Context Rot) and making mistakes.

The agent is given an isolated (walled-off) cell where it's only shown "just enough information to do its own specific task." This way the agent doesn't drown in unnecessary libraries and doesn't run into Focus problems.

Context Window

This is the maximum "short-term working desk" capacity an AI model can lay out in front of itself and process at once.

Once that desk fills up, the AI starts forgetting older information; in long conversations this creates the risk of Lost in the Middle, and over time, Context Rot.

To get around this memory limit, architectures use RAG or Long-Term Memory.

Contrarian Agent

This is a critical agent profile inside Debate Loops that deliberately opposes and objects to the ideas and code other agents produce.

It stress-tests from the inside with Red Teaming logic. Its job is to find weak spots (edge cases) to keep the team from getting complacent and push it toward perfection. Where a standard Reviewer Agent looks for compliance, the Contrarian Agent looks for weakness.

Copilot (GitHub/Microsoft)

This is the AI assistant built by Microsoft and GitHub that gives developers instant code suggestions and chat support.

Its core difference from Agentic IDE systems (e.g., Cursor, Antigravity IDE) and their traditional versions is that it's focused on code completion, can't start its own autonomous cycle (Agentic Loop), and can't act independently in the outside world like a Worker Agent. Even though newer plugins push its boundaries further, at its core it's still an assistant model tightly bound to human commands.

Copywriting

This is the art of writing sales-focused, persuasive text with a call to action (CTA). Landing page headlines, ad copy, and email subject lines all fall under this discipline.

Autonomous agents can analyze A/B testing data to see which tone of copy drives higher Conversion Tracking and generate content recommendations from it.

Core Web Vitals

These are Google's 3 core metrics for measuring a web page's user-experience quality:
- LCP (Largest Contentful Paint): How long it takes the page's main content to load.
- INP (Interaction to Next Paint): How fast the page responds to a user's click.
- CLS (Cumulative Layout Shift): How much the page's visual elements shift around.

They directly affect SEO rankings. They're measured with PageSpeed / Lighthouse tools. Autonomous agents can analyze these metrics and suggest CDN and code optimizations.

Cost Control Limits

These are hourly/daily financial barriers and caps placed on autonomous agent platforms.

They stop an agent that's fallen into an infinite loop due to an error from firing off hundreds of unnecessary API requests (ACT) back to back and blowing up its Token Burn Rate. They form the numeric rules of the Budget Guardrails architecture; when a limit is exceeded, the system automatically cuts off the agent's access to prevent a blowout.

Crawling

This is the process where Google's and other search engines' bots (Googlebot) systematically move through websites, read their content, and save it to a database (Indexing).

The robots.txt file determines which pages get crawled, while the Sitemap lists which pages should be crawled. Autonomous agents can spot and fix crawl errors through Google Search Console.

Critic / Reviewer Agent

This is an independent quality-control agent built purely for auditing and review, taking on the "Checker" role in the Maker-Checker Architecture model.

When the Implementer Agent finishes its work, this agent looks at the output with a blank, unbiased memory and checks whether it meets the standards. If it approves, the code gets merged; if it finds an error, it sends autonomous feedback for a fix.

Cron (Scheduled Tasks)

This is scheduling infrastructure that lets agents wake themselves up and run tasks entirely in the background (Daemon) at fixed intervals (e.g., every hour), without human (HITL) approval.

For example, an agent scanning the database every night to generate a report, or running Campaign Syncing every hour, is handled by cron triggers at the Agent OS level.

CSS / HTML / JavaScript

These are the web's 3 core building-block technologies:
- HTML: Builds the page's skeleton (structure).
- CSS: Determines the page's appearance (design, colors).
- JavaScript: Adds interactivity and dynamic functionality to the page.

Autonomous agents use these 3 languages inside an Agentic IDE to produce websites with Responsive Design. A Browser Sub-Agent then autonomously tests this code through the DOM.

CSV / JSON

These are two common formats used for moving and storing data:
- CSV (Comma-Separated Values): A simple text format that stores table data separated by commas. Campaign reports, product lists.
- JSON (JavaScript Object Notation): A format that stores structured data as key-value pairs. The base language of API, MCP, Function Calling, and Schema Markup communication.

Curate / Curation

This is the process of taking the thousands of pages of complex data agents find (through RAG and similar methods) and, instead of sending it straight to the main model, weeding out the junk and shaping it into something synthesized and contextually appropriate.

By filtering out unnecessary data (Context Pruning), it keeps the agent from suffering Lost in the Middle syndrome. Uncurated raw data wears down the agent's memory and degrades its quality.

CI/CD (Continuous Integration/Deployment)

This is the automated pipeline for a piece of software, running from being coded to being tested and pushed live (Deploy) — Continuous Integration / Continuous Deployment.

Within the SDLC (Software Development Life Cycle), autonomous agents can have a Reviewer Agent audit the code, and once it passes tests, autonomously deploy it through the CI/CD pipeline. It works integrated with GitHub.

Daemon

These are ghost agentic (Sidecar) processes that listen 24/7 in the operating system's background and wait for commands, even after the terminal window is closed.

They stay awake continuously and watch for events in the system. For example, triggering systems that instantly detect when a new file lands in the system and autonomously spin up a Worker Agent in response depend entirely on Daemon processes.

Dashboard

This is a monitoring screen that summarizes KPI metrics, campaign performance, and site traffic with visual charts, tables, and maps.

It's built in natively on platforms like Google Analytics (GA4), Google Ads, and Meta Ads. Autonomous agents can build custom dashboard reports in Artifacts format to give humans (HITL) a quick status summary.

Data Layer

This is the on-page JavaScript data layer that lets a website communicate with Google Tag Manager (GTM). User actions, product info, and page data all get written to this layer.

It's the foundation for Tag and Trigger configuration. Autonomous agents can detect missing Data Layer variables and suggest fix code.

Data Privacy

This is the legal and ethical protection principle applied to how users' personal data (name, email, location, behavior) is collected, processed, and stored.

It's regulated by laws like GDPR (Europe) and KVKK (Turkey). Cookie Consent and Consent Mode are the technical implementations of this principle. Autonomous agents protect privacy in Multi-Tenant systems by enforcing data isolation.

Debate Loops

These are asynchronous processes where multiple agents argue with each other in a loop until they reach consensus on a shared design or piece of code.

These rooms bring together Implementer, Reviewer, and Contrarian agents, keeping the system from being stuck with the decisions of a single model (Hallucination) and autonomously raising output quality through multiple perspectives.

Decentralized Agent Networks

This is a decentralized working model in multi-agent architecture (MAS) based on a flat (P2P) structure, where the network is managed without a central "dictator" agent like the Conductor.

Agents don't wait for orders from outside; they make their own decisions autonomously and communicate directly with each other via A2A (Agent-to-Agent). It's more innovative than the Centralized Agent Networks model, but it needs stricter Guardrails against the risk of infinite loops or chaos.

Deep Reasoning

This is when an AI, before producing direct output (an answer), spends hours or minutes in the background in a hidden loop, analyzing the problem by questioning itself (Chain of Thought) and building probability trees (Tree of Thoughts).

It's the foundation of next-generation advanced reasoning models. It's the exact opposite of the simple, speed-focused Fast Mode approach; it's what solves the toughest 10% of tasks in complex Agentic Engineering architectures.

DeepSeek

This is a Chinese-origin AI model family that's open-source and low-cost, yet still delivers strong Deep Reasoning capacity. Because developers can host it on their own servers (self-hosted), it offers advantages in data privacy and control over Token Burn Rate.

It offers a strong, budget-friendly alternative to expensive Deep Reasoning models, and is often chosen as the Orchestrator brain in Compound AI System architectures.

Definition of Done

These are strict technical success (control) criteria that keep agents from leaving work half-finished or getting stuck in an unnecessary infinite loop after hitting an error.

They include fixed requirements like "tests must pass, code must be committed, and a JSON report must be returned." They let the agent know autonomously when to stop working on a task; the system doesn't leave the Observe stage until these criteria are met.

Deliberative / Planning Agents

This is a type of methodical, thinking agent that, when it hits a problem, pulls back and analyzes the scope of the project first — instead of diving straight into code and taking action the way Reactive Agents do.

Before it moves, it prepares a blueprint (Plan/architecture), presents that plan as an Implementation Plan, and usually waits for approval from a human (HITL) or a senior conductor before taking action (ACT).

Deploy

This is the process of moving developed code or a website from the test environment to the live server (Production).

It's automated through CI/CD (Continuous Integration/Deployment) pipelines. Autonomous agents can have a Reviewer Agent audit the code, commit it through Git, and trigger an automatic deploy. It's the final step of the Definition of Done criteria.

Discover

This is the first step an agent takes when starting the Agentic Loop process. It means scanning folders and reading environment variables to understand the task at hand.

During this prep stage, the agent uses Dynamic Tool Discovery to identify which Tools it has on hand, and builds context by doing a strategic situation assessment (discovery) before moving into the Plan stage.

Docker

This is the technology that wraps applications and all their dependencies into isolated, portable "container" packages, so they run the same way in every environment.

It's used in agent security to build the Execution Environment (Sandbox). It serves a similar purpose to nsjail, blocking at the hardware level any harm the code an agent runs could do to the host system.

Doer / Executor

This is the worker agent that's stripped of architectural planning or code-review (Reviewer) duties within the team, and just carries out the operation in the field, sticking exactly to the plan the Planner agent drew up.

Its main job is to write the raw code, trigger Tools calls, and run terminal commands. It makes up the "Maker" (producer and muscle) half of the Maker-Checker Architecture model.

DOM (Document Object Model)

This is the live document model a web browser builds when it reads an HTML page, representing every element on the page (button, text, image) as a tree structure.

A Browser Sub-Agent works through the DOM when interacting with a page — finding buttons, filling forms, and clicking elements. It's the basic structure an agent "reads" the page through during UI Testing workflows.

Domain

This is a website's unique address on the internet (e.g., `example.com`). It's routed to the server's IP address through DNS (Domain Name System).

A secure connection (HTTPS) is provided by an SSL Certificate. From an SEO standpoint, a domain's age, authority, and whether it contains a keyword can all affect rankings.

Dynamic Context

This is a method where, instead of piling a project's massive library data into memory from end to end as Static Context, only the relevant scraps of data are pulled from RAG based on the agent's actual need.

It works on Lazy Loading logic. It doesn't waste the system's Context Window capacity, and by leaving unnecessary data out, it speeds the agent up while preventing Context Rot risk.

Dynamic Tool Discovery

This is the feature where, when a new MCP Server gets connected to the system, the agent scans the server and reads and learns the new list of Tools and capabilities it can use on its own — without a developer having to manually introduce each tool to the agent.

Thanks to this flexibility, the agent instantly adds new tools to its portfolio during the Discover stage, and autonomously triggers those new tools during the ACT stage.

Edges

In State Graph architectures like LangGraph, these are the connecting paths that represent the logical transitions and data-flow direction between an agent's working stops (Nodes).

For example, the path from the "Code written" node to the "Run tests" node is an Edge. They determine the routes agents will autonomously draw based on if/else rules, and they form the system's routing mechanism.

Embeddings

These are the numeric coordinate equivalents that machines convert the words or code blocks in a document into — arrays of numbers with hundreds of dimensions — so they can be searched "semantically" inside a Vector Database.

They're the basic requirement for doing Semantic Search. Thanks to these numbers, the model grasps the logical closeness between pieces of text, moving Agentic RAG workflows out of keyword matching and into a semantic format.

Environment Variables

These are key-value pairs where API keys, database passwords, and secret credentials are stored securely at the OS level, instead of being written directly into the source code.

They're critical for Data Privacy and Governance. Autonomous agents reading these variables safely during MCP Server connections or Deploy workflows is handled within ACL boundaries.

Episodic Memory

This is the experience-based long-term memory layer where an agent keeps, like a filmstrip, the sequence of steps (Trajectory) it took to complete a complex task in the past, including the mistakes it made and how it fixed them.

Unlike Semantic Memory data (rules and facts), Episodic Memory is entirely based on "lived experience." It keeps the agent from repeating the same mistakes on similar problems in the future.

Evals (Evaluation / Hard Evals)

This is the process of measuring (stress-testing) the agent you've built with thousands of autonomous test scenarios — not just settling for it succeeding at a couple of simple tasks, but assessing code quality, its Hallucination rate, and its ability to recover from tough situations.

It's usually scored by another advanced model (LLM-as-a-Judge). In Agentic Engineering architectures, an agent must pass these heavy tests before it can go to production.

Execute

This is the final stage where the agent applies the strategy it built during the Plan stage to the physical/digital world.

In this operational step, the agent fills in the relevant Tools parameters as JSON, runs code in the Terminal, or writes a database record — carrying out an actual action (ACT) in the outside world. Right after Execute finishes, the system moves into the Observe stage to evaluate the results.

Execution Environment (Sandbox)

These are fully isolated virtual cells set up to keep the raw code and system commands autonomous agents actually run via CLI Tools from leaking into and damaging the user's host operating system.

They're provided through nsjail (Seatbelt) or Docker containers. Backed by an ACL (Access Control List), an agent falling into an infinite loop or deleting the system is restricted at the hardware level.

Fallback Strategy

This is when, instead of the system locking up and failing outright, the agent autonomously switches to "Plan B" (by detecting the error message) if the main model it's connected to crashes (an LLM Gateway outage) or an external API stops responding.

By including actions like switching to an older/cheaper backup model or triggering a different Tools method when an error hits, it keeps the Self-Correction philosophy alive.

Fast Mode (Heuristics)

This is a working mode where the agent handles routine work that doesn't need Deep Reasoning — text parsing, simple translation, or JSON formatting — with much smaller, reflexive, fast models instead of giant ones, per the "60/30/10 Rule."

It lets the agent work off memorized rules (Heuristics) instead of running complex reasoning, which minimizes Token Burn Rate (cost).

Few-Shot Prompting

This is the art of giving an agent 2-3 flawless reference examples (in input-output form) of exactly what you expect, inside a SKILL.md file — instead of just explaining a complex task with rules alone (Zero-Shot).

Using these example patterns as a reference, the agent doesn't drift from the format you asked for. It's the most effective technique for getting Structured Output (structured JSON or custom Markdown output) and aligning the system.

Fine-Tuning

This is the process of retraining a general-purpose LLM model with data specific to one field (e.g., medical terminology, legal language, customer service) to make it a specialist in that domain.

It shouldn't be confused with Prompt Tuning (prompt optimization). Fine-Tuning changes the model's weights, while Prompt Tuning only optimizes the input text. It's far more expensive in both cost and time.

Firestore (Firebase)

This is a real-time, serverless NoSQL database — commonly used in Multi-Tenant or cloud-based agent projects — where agents safely sync the rules they learn autonomously, Job Memory records, and session logs.

It's fast compared to local files (JSON/TXT) and provides powerful infrastructure that lets agents instantly share Long-Term Memory data across users (with isolation).

Function Calling

This is the action where an LLM, instead of just turning into text for a human, reads the list of external tools (Tools) the system offers it, decides "I need to run this tool on the database to solve this task," and autonomously fills in the right parameters for that tool (in JSON format) and passes them to the local system.

It's the building block of Agentic AI architectures, because it turns the model from a passive chatbot into an active machine that can physically intervene (ACT) in the outside world.

Gemini (Google)

This is the AI model family built by Google DeepMind that can process text, image, audio, and video all at once (Multimodal) — Gemini Pro, Ultra, Flash.

It's a direct rival to OpenAI's GPT series and Claude. Thanks to its deep integration with the Google ecosystem (Search, Ads, Analytics), it offers a strong brain alternative for Agentic AI systems, especially for data-analysis and search-optimization tasks.

GEMINI.md / AGENTS.md

This is the central rules document, sitting at a project's root directory, that holds the fundamental laws (Workspace Rules) every agent working on that project must read and follow.

Where SKILL.md files teach agents "how to do it," these documents define "what must absolutely never be done" and the project's coding standards. Before starting a task (Discover), the agent loads this constitution into memory to build project-specific context.

GEO (Generative Engine Optimization)

This is the strategy of getting your brand or content referenced by AI-powered search engines and chat assistants like ChatGPT, Gemini, and Perplexity.

Unlike traditional SEO, it's not just about ranking — it focuses on the AI's "citation" criteria. Schema Markup, E-E-A-T authority, and clean, structured content (Structured Output) are the core tools of this process.

Git

This is the distributed version-control system that timestamps every code change in a software project, making undo and parallel work possible.

The Git Worktree feature lets autonomous agents work in isolated branches without breaking the main project. Used together with GitHub, it automates CI/CD pipelines and Deploy workflows.

Git Worktree

This is a Git feature that lets you run different versions (branches) of the same project independently, in different folders, at the same time.

It's extremely valuable in autonomous systems because traditional branch-switching can confuse agents and create Context Rot. A Worker Agent can safely do its work in a fully isolated worktree folder (its own sandbox) while the main system (Host) keeps handling other operations without interruption.

GitHub

This is a Git-based code hosting and collaboration platform. It's used worldwide as the central repository for open-source projects and enterprise software.

Autonomous agents can connect to GitHub through an MCP Server to autonomously run tasks like code review (Reviewer Agent), auto-commit, opening pull requests, and triggering CI/CD.

Global Skills

These are universal capability (Agent Skills) packages that don't belong to just one project — they live in a central directory on the machine, like `~/.gemini/config/skills`, and every agent on that system can use them.

Where Local Skills only hold the rules of the project they live in, Global Skills teach an agent general-purpose capabilities (e.g., how to connect to a database, how to deploy to AWS).

Goldfish Memory Problem

This is a model's tendency to forget things said just a few messages ago, or critical data it found earlier.

The cause is either the Context Window limits filling up or Lost in the Middle syndrome. For agents to get past this problem, they need to connect to persistent Long-Term Memory infrastructure — like Mem0, Firestore, or local JSON files — instead of relying on momentary memory.

Governance

These are the enterprise management policies that determine who hundreds of different autonomous agents in an organization can talk to, what data they can access, and which boundaries they can't cross.

ACL (access control) and Guardrails (security boundaries) are the technical implementers of Governance. It's the most important architectural umbrella layer that prevents chaos, especially in Multi-Tenant (multi-user) or financial agent systems.

Grounding

This is when a model, instead of relying on its own imagination (Hallucination) while answering questions or writing code, plants its feet firmly on real, verified data from the outside world (RAG or API results).

It's the ultimate goal of the Agentic RAG cycle; it adds credibility to the system by making sure every sentence or decision the agent produces has a piece of evidence (citation) backing it up.

Guardrails

These are the rigid "security fence" and safety barriers drawn around an autonomous agent.

Unlike classic System Prompt instructions, they're not a text-based request — they include ACL access restrictions and code-level security rules that can't be breached.

They block malicious Prompt Injection attacks and stop the agent from deleting critical data or exceeding its Budget Guardrails limits.

Hallucination

This is when an AI model, instead of honestly saying "I don't know" about something it doesn't know, produces extremely convincing but entirely made-up and incorrect information (or non-working code).

In autonomous systems, if this fabricated code gets run directly during the ACT stage, it can crash the system. To prevent this:
- Grounding: Tying the answer to real data
- Curate: Refining data beforehand
- Maker-Checker Architecture: Independent review

Hard Evals

These are automated, mathematically provable, ruthless test batteries made up of thousands of tough scenarios — instead of measuring an agent's quality by human observation or a couple of simple examples (Vibe Coding).

They measure how well the system holds up under Red Teaming tests and how it escapes an infinite-loop spiral. In enterprise systems, they're the most important piece of the Definition of Done criteria.

Harness

This is the abstraction (wrapper) software that wraps different brands and models (e.g., OpenAI, Claude, DeepSeek) and connects them to the hardware, so they can all run in a standard way inside the same Agent OS or structure.

It keeps the developer from having to write separate code for every model; by giving each model a standard Function Calling interface, it turns it into just another gear in the larger machine.

Heuristics

This is when agents produce reflexive, fast, cheap solutions based on predefined rules ("If x, then do y"), instead of running lengthy Deep Reasoning for every decision.

It runs under Fast Mode. These are the shortcut, practical-intelligence steps that keep agents from burning excessive tokens (cost) across multiple tasks.

Hierarchical AI Agents

This is a hierarchical working model where agents are organized in a chain of command, like in the military.

At the top sits a Conductor who sees the big picture; below it are Planner agents who do the planning, and at the bottom are the Worker Agent units who actually carry out the work. It's the safest Multi-Agent System architecture for breaking large, complex projects into pieces and solving them.

Host (MCP)

In MCP (Model Context Protocol) architecture, this is the main platform that houses the model and the client (Client) and kicks off the process (e.g., Cursor IDE, Claude Desktop, or Antigravity CLI).

The Host connects to an outside MCP Server to offer the agent new Tools and Resources, and it's the umbrella environment that the entire agent infrastructure runs on top of.

Hosting

This is the server service where a website's files (HTML, CSS, images) are physically stored and made available for access over the internet (e.g., AWS, Google Cloud, Hetzner).

A site's speed, security, and uptime depend directly on hosting quality. It affects Core Web Vitals and PageSpeed / Lighthouse scores. It's used together with a CDN to optimize performance.

Hreflang

This is the HTML tag on multilingual or multi-region websites that tells search engines "This page is for Turkish, the English version is over here."

It's critical for SEO; used incorrectly, different language versions of the same content end up competing with each other (cannibalization). It works together with the Canonical URL. Autonomous agents can scan multilingual sites for Hreflang errors and fix them.

HITL (Human-in-the-Loop)

This is a security and oversight architecture that pauses the agent at critical, risky steps (money transfers, deleting a database, etc.) while it's running autonomously, and asks for **human approval**.

Unlike fully unsupervised Always Proceed mode, it keeps control of the system with the developer.

During its decision-making stage, the agent fires off a Request Review call and waits for a human to approve it.

identity.md

This is the core character (identity) file that defines an agent's (or AI assistant's) personality, purpose, tone, and main mission.

For example, one agent might say "I'm a strict security auditor," while another says "I'm a creative marketing specialist." When the system starts up, this file is injected first into the System Prompt, shaping the agent's persona.

Job Memory

This is the Short-Term Memory space where the agent keeps the state, errors hit, and stages passed for the specific task it's currently working on.

When the task finishes successfully or gets canceled, this memory is usually cleared or summarized and permanently moved into Episodic Memory. It's the answer the agent gives itself to "What was I doing?" in the moment.

JSON Hooks

These are the agent-ecosystem equivalent of traditional webhooks. They're internal connectors that fire autonomously and kick off another process when a specific event happens in the system (e.g., a file changes, an agent hits an error).

Working integrated with Daemon services, they make the system reactive and let agents communicate with each other via A2A.

JSON Validation

This is the validation layer that instantly tests whether the JSON text an agent generates during Function Calling or output generation is structurally error-free (no syntax errors) and has the expected fields (e.g., "name," "age").

It's run by the Schema Validator; if there's an error, it stops the system from breaking by autonomously sending the agent a "the JSON is broken, rewrite it" command.

JSON-RPC 2.0

This is the stateless, quite lightweight remote procedure call protocol that forms the backbone of MCP (Model Context Protocol) communication.

Every message that goes back and forth between the Client and Server (requesting a Tools list, running a tool, etc.) travels entirely over this simple JSON standard, keeping the systems talking fast and stable.

Knowledge Subagent

This is a ghost agent that reads and analyzes a project's massive codebase, documents, and past conversations in the background (while the user sleeps or the system is idle), converting them into Embeddings and indexing them.

Working on Daemon logic, it raises the system's search quality (Semantic Search) and prepares the infrastructure that lets active worker agents instantly reach the information they need.

Knowledge Vault

This is the central storage area where agents keep the persistent knowledge they've learned (Long-Term Memory), system logs, and user preferences in an isolated, encrypted form.

It can be kept in a cloud service like Firestore, or it can live entirely on your local disk (e.g., a `.gemini` folder). It's the physical data store that solves an agent's amnesia problem.

Knowledge Items (KIs)

These are information packages, stored in the `appDataDir/knowledge` directory and containing `metadata.json` plus documents, that make up a project's or organization's institutional memory.

Before writing code or making a decision (during the Discover stage), an agent reads these packages to learn the project's previously made architectural decisions, known bugs (gotchas), and SOPs (Standard Operating Procedures), joining the project from behind the Context Wall.

KPI (Key Performance Indicator)

This is the numeric target metric set to measure the success of a piece of work. In marketing, values like ROAS, CTR, CPA, and Bounce Rate are all KPIs.

Autonomous agents continuously track set KPI targets during the Observe stage, and change strategy with Self-Correction if a target isn't being hit. It's the basic building block of Dashboard reports.

KVKK

Turkey's Personal Data Protection Law. It's the legal framework Turkey put in place, for a purpose similar to GDPR (Europe), regulating how personal data is collected, processed, and stored.

The mandatory Cookie Consent banner, privacy notice, and explicit consent mechanisms on websites are requirements of this law. Autonomous agents can check KVKK compliance during site audits.

LangGraph / LangChain

These are the most popular orchestration frameworks that let you build an autonomous agent's decisions and Workflows as a node graph (State Graph) of logical Nodes and connections (Edges), instead of plain-text code.

They keep agents from falling into infinite loops, offer rollback mechanisms, and make the Agentic Loop process mathematically controllable.

Latency

This is the wait time, in milliseconds, from when an agent (LLM) receives input to when it produces the first word (output) after thinking (Reasoning).

It's vital in enterprise agent architectures (e.g., voice assistants or Fast Mode processes). When designing a Compound AI System, the right model is chosen by balancing speed (low latency) against intelligence (high accuracy).

Lazy Loading

This is the strategy of dynamically pulling data from the database exactly when the agent needs it, instead of loading massive unneeded data or the Tools list into the agent's memory (Context Window) upfront.

It prevents Context Rot and multiplies performance in Agentic Engineering architectures by cutting token usage.

Learner Agent

This is a self-training agent that analyzes the mistakes other agents in the system make (logs from the Observe stage) and the interventions humans make (HITL), learns from them, and autonomously writes new Local Skills or updates existing system prompts.

It runs the Memory Consolidation process. By making the system stronger every time it makes a mistake, it makes the Self-Correction ability permanent.

LLM (Model / Brain)

Large Language Model. This is the central brain of the agent system — the pure text understanding and generation muscle (e.g., DeepSeek, GPT, Claude).

Unlike AI assistants (ChatGPT), in autonomous systems the LLM isn't a standalone product — it's just one of hundreds of components inside a Compound AI System. The agent uses the LLM brain to do Reasoning and trigger tools.

LLM Gateway

This is the proxy/server layer an agent passes through — instead of connecting directly to the AI models behind it (OpenAI, Anthropic, etc.) — that manages API keys, Rate Limiting, and load balancing (e.g., LiteLLM).

It's the center of the Fallback Strategy implementation. When a model crashes or stops responding, the Gateway instantly shifts traffic to another model, letting the agent keep working uninterrupted instead of falling into an infinite-loop spiral.

LLM-as-a-Judge

This is another independent, usually smarter (e.g., top-tier reasoning) model used to score and audit the output an agent produces during Evals (stress tests) or quality-control stages, without needing human (HITL) intervention.

It serves as the "Checker" in the Maker-Checker Architecture model. It runs the code an agent writes and scores the output out of 10, maximizing automation speed.

Local Skills

These are expertise (know-how) packages that only live inside the folder of the project they belong to (e.g., `.agents/skills`), version-controlled with Git Worktree, holding architectural rules and Tools usage patterns specific to that project.

Unlike Global Skills (system-wide skills), Local Skills are isolated. They give an agent targeted, permanent Procedural Memory, like "How do you write React components on this specific project?"

Long-Term Memory

This is the "permanent memory store" that carries an agent's experience from past sessions, user preferences, and institutional knowledge forward into the future.

It gets past the limitation of Short-Term Memory, which gets wiped at the end of a session.

It stores data in a Vector Database and feeds Semantic Memory and Procedural Memory structures, letting the agent learn over time (Learner Agent).

Loop Engineering

This is the discipline of designing unbreakable workflows where agents trigger and correct themselves inside an Agentic Loop until they reach the goal, instead of working off one-off commands (classic Prompt Engineering).

The goal is to build solid Fallback Strategy mechanisms to keep agents from crashing, and to set firm Definition of Done stop conditions that keep them from falling into an infinite-loop spiral.

Lost in the Middle

This is the ailment where an agent (LLM) — once thousands of lines of code or text have piled up inside a massive-capacity Context Window — remembers the very start and very end of the document but overlooks and skips critical sections sitting right in the middle.

To prevent this memory poisoning (Context Rot), instead of dumping everything into the system directly, it should be given curated summaries, and data should be broken up with Semantic Chunking.

Maker-Checker Architecture

This is the autonomous, asynchronous control loop between the Implementer Agent that actually produces the work (Maker) and the Reviewer Agent that ruthlessly audits the resulting output (Checker).

Since having a human review every piece of code (HITL) would create a bottleneck, this architecture lets code and text get produced at high quality and error-free through cross Red Teaming tests, without needing human intervention.

MCP (Model Context Protocol)

This is the universal "plug-and-play USB cable" standard that lets AI models talk to databases, file systems, and external services.

Unlike traditional API or custom integration solutions, it removes the need to code a separate API Connector for every platform.

It manages the capabilities offered to the AI as Tools, data as Resources, and command templates as Prompts — 3 core MCP Server components.

MCP Client

In MCP (Model Context Protocol) architecture, this is the bridge interface that runs inside the Host application (e.g., Cursor or Antigravity IDE) and kicks off communication between the model and the external server.

It receives the Function Calling requests the model makes in natural language or simple JSON, converts them into standard JSON-RPC packets, and forwards them to the MCP Server, letting the agent exchange data with the outside world.

MCP Server

This is the service (server) layer that opens up an external database, a GitHub repository, or a local folder to the outside world by translating it into a standard format the agent (LLM) can understand.

It offers the agent 3 core components: Tools (actions), Resources (readable data), and Prompts (templates). The agent connects to this server through an MCP Client and autonomously manages external systems within its permissions (ACL).

Mem0

This is an external long-term memory database solution built specifically to solve agents' amnesia problem (Goldfish Memory Problem).

Even after sessions (Working Memory) close, it stores the important past conversations an agent had with a user, their preferences, and Episodic Memory logs. It gives the agent a consistent Long-Term Memory experience, letting it remember the user in every new session.

Memory Consolidation

This is the process of an agent analyzing and summarizing the complex error logs, conversations, and code attempts that built up in Job Memory throughout the day, and turning them into clean, permanent institutional knowledge (Knowledge Items) at the end of the day (or when the task finishes).

It prevents Context Rot and ensures the agent only carries distilled experience into Long-Term Memory.

Meta Tags

These are the tags in an HTML page's `` section that tell search engines and social media platforms about the page.
- Title Tag: The page title (the blue link in Google results)
- Meta Description: The page description (the gray text in Google results)
- Canonical: The page's true address

They directly affect SEO rankings and CTR. Autonomous agents can spot and fix missing or poorly written meta tags.

Metadata Tagging

This is the process of adding invisible identity (JSON) tags — like "date, author, topic, expiry" — to files agents create, especially Knowledge Items packages.

During Agentic RAG and Semantic Search, it lets the agent filter down to just the data with relevant tags instead of getting lost among billions of records. It's the most fundamental indexing rule that keeps large Multi-Agent System projects organized.

Multi-Agent System (MAS)

This is the "team and swarm architecture" where multiple specialist agents work together to accomplish a complex task.

Instead of loading every task onto one giant agent, it divides labor among specialist Worker Agent units (coder, tester, researcher) under the leadership of an Orchestrator.

Agents communicate with each other via the A2A (Agent-to-Agent) protocol.

Multi-Tenant (Isolation)

This is the architecture where the data of hundreds of different users or companies using the same agentic infrastructure (e.g., a Telegram bot or a SaaS panel) is kept in fully isolated cells in databases like Firestore, never mixing together.

It's critical for Governance; thanks to Identity Propagation, an agent reading Customer A's file can never accidentally reach Customer B's data (enforced by Guardrails).

Multimodal

This is an AI model's ability to understand and process not just text, but different data types at once — image (Vision), audio, and video.

Current models like GPT and Gemini are multimodal. Multimodal ability is used when a Browser Sub-Agent analyzes screenshots, spots visual bugs during UI Testing, or evaluates ad creative.

n8n

This is an open-source workflow automation platform you can host on your own server (self-hosted). It's an alternative to Zapier / Make, but offers advantages in data privacy and cost.

Autonomous agents can trigger n8n workflows through an MCP Server or Webhook to run multi-step automations like CRM updates, email automation, or report generation.

Narrow AI

This is the concept describing today's general state of AI — able to perform only a specific task (e.g., playing chess, writing code, generating images) at or above human level, but unable to understand anything outside that.

It's the exact opposite of the hypothetical do-everything level of AGI. Agentic systems aim to get past these narrow limits by combining different Narrow AI specialists under a single Orchestrator.

Nodes

In architectures like LangGraph or a State Graph, these are the independent working stops an agent passes through, each carrying out a function (e.g., "search the web," "test the code," "produce the answer").

Nodes are connected to each other by Edges. When the agent finishes its work at one node, it moves the data it produced (State) to the next node, advancing the autonomous workflow.

NoSQL

Unlike traditional table-based (relational) SQL databases, this is a database family that stores data as flexible-schema (JSON-like) documents (e.g., MongoDB, Firestore, Redis).

It's well suited for autonomous agents to quickly read and write Long-Term Memory and Job Memory data. In Multi-Tenant architectures, user data is kept isolated in NoSQL collections.

Notification System

This is the mechanism autonomous agents use to send instant notifications to a human (HITL) when a critical event happens (an error, a task finishing, a budget overrun).

It works through channels like a Telegram Bot, Slack Integration, email, or push notifications. Integrated with Daemon services and JSON Hooks triggers, it enables autonomous monitoring.

nsjail

This is a Linux-based, extremely strict hardware-level Execution Environment (Sandbox / isolated cell) tool used to keep the raw code autonomous agents actually run through CLI Tools (Terminal commands) from leaking into and damaging the user's host operating system.

Working on ACL (access control) logic, it locks down the agent's processor, memory, and network access. It's the ultimate fuse for system security.

Observe

This is the "sense and perceive" phase where the agent reads the system's new state, error output, and environment responses after carrying out an action (ACT).

It's the control mechanism of the Agentic Loop cycle; it feeds the incoming output into the Reasoning stage, letting the agent update its next Plan step.

For example, when a command that's run throws an error, the agent observes that state and kicks off the Self-Correction process.

Open Source vs Closed Source

This is whether an AI model's or piece of software's source code is open to everyone (Open Source) or kept private by the company (Closed Source).
- Open Source: DeepSeek, LLaMA, Mistral — can be run on your own server, giving you a data privacy advantage.
- Closed Source: OpenAI GPT, Claude, Gemini — used through an API, data goes to the company's servers.

It's a critical choice in Governance and Data Privacy decisions.

OpenAI

This is the pioneering company in autonomous AI that built ChatGPT and the GPT family of models.
- Standard Models (GPT series): fast, low-cost models, preferred for both Fast Mode and general tasks.
- Deep Reasoning Models: deep-reasoning models that solve complex problems by running Chain of Thought for minutes at a time.

Rivals: Claude (Anthropic), Gemini (Google), DeepSeek (open source). Because the top-tier models in particular carry high cost and processing time, under the 60/30/10 Rule they're usually reserved for only the most critical Orchestrator tasks (architectural decisions).

Orchestration

This is the process of managing dozens of otherwise disorganized, independently running agents, APIs, and tools (Tools) in harmony — like a symphony orchestra — around a defined workflow and Governance rule, without creating chaos.

It's the main feature that sets Agentic AI systems apart from simple chatbots. It manages errors (Fallback Strategy), distributes tasks, and keeps the system whole.

Orchestrator

In multi-agent systems (Multi-Agent System), this is the "main manager" agent that runs the orchestra and breaks complex tasks into sub-parts.

It distributes work to Worker Agent units, routes processes with Agent Routing, and synthesizes the results that come back.

It's the heart of the Orchestrator-Worker Pattern architecture; when needed, it gets HITL approval from a human to oversee the process moving forward.

Orchestrator-Worker Pattern

This is the classic, hierarchical, centralized agent architecture template, with a Conductor (Orchestrator) who sees the big picture at the top, and Workers (Worker Agent) below it who actually carry out specific jobs (development, design, testing).

It's the most commonly chosen structure for avoiding chaos in large projects. Even though workers communicate with each other via A2A, the final decision and approval always comes from the Orchestrator (or a human, via HITL).

Output Format

This is when the response an agent (LLM) produces comes in a structured data format (e.g., JSON, XML, Markdown) that external systems or other agents can read and run directly, instead of random plain text.

It's the foundation of Structured Output requirements. Using validation mechanisms like Few-Shot Prompting and Pydantic (JSON Validation), it keeps the agent from drifting out of format (Hallucination) and ensures Function Calling runs error-free.

PageSpeed / Lighthouse

These are Google's free performance testing tools that measure a web page's load speed, accessibility, and SEO compliance.

They report Core Web Vitals (LCP, INP, CLS) metrics. Autonomous agents can autonomously run Lighthouse tests through a Browser Sub-Agent and suggest CDN, image compression, or code optimizations for low-scoring areas.

Plan

This is the second of the 4 core stages inside the Agentic Loop (Discover, Plan, Reason, Act). It's the stage where, after observing the environment, the agent breaks a large, complex task into small, manageable sub-tasks (steps).

The agent doesn't move straight to action (ACT) at this stage. Deliberative Agents (Planner Agents) in particular map out the system's route at this stage by preparing a detailed blueprint (architecture) or Task Plan (task list).

Planner Agent

In hierarchical (Hierarchical AI Agents) systems, this is the analytical specialist agent focused purely on building strategy, instead of writing code directly (Doer/Executor) or debugging.

Its job is to break the main request it gets from the Conductor into pieces, decide which Tools to use, and produce an Implementation Plan. It submits the plan it produces for approval (HITL) and, once approved, hands it off to Worker Agent units to carry out.

Pragmatist Agent

This is a results-focused agent that clashes with the Reviewer Agent hunting for perfection or overly academic code standards inside Debate Loops, keeping the system focused on the "fastest, working" solution instead.

Especially when Definition of Done criteria are flexible, it stops the system from falling into an infinite-loop spiral and burning too much Token Burn Rate; it pushes the good-enough solution through.

Presenter Agent

Unlike lower-level agents that work in the background and produce complex database logs and JSON formats, this is the interface agent that turns raw results into a visual, interactive Artifact or Walkthrough (report) the end user (a human) can understand.

Using the Progressive Disclosure principle, it doesn't drown the user in information — it just presents the clean summary needed for approval (HITL).

Principle of Least Privilege

This is the rule that an agent or a Sidecar microservice should only ever be given the "minimum level" of permission it needs to do its job.

It's the backbone of Governance and system security. If an agent only needs to read a folder, it's never given write or delete permission for it through the ACL (Access Control List). This way, if a Prompt Injection attack succeeds, the system as a whole isn't harmed.

Privilege Boundaries

These are the invisible walls that separate the permission and access limits of different agents in a system (e.g., a Customer Service Agent vs. a Database Admin Agent) or different projects (Multi-Tenant), both at the hardware and software level.

They're strictly managed by the Agent OS. An agent that tries to violate these boundaries is instantly blocked by Guardrails or nsjail (Sandbox), stopped with a Segmentation Fault-style emergency hard stop.

Procedural Memory

This is the persistent expertise memory where an agent keeps the steps (the way of doing things) for specific work, like "How do you create a React component?" or "How do you deploy to AWS?"

It's loaded into the agent through SKILL.md files or Local Skills packages. Unlike Semantic Memory (facts) or Episodic Memory (past experiences), it holds task standards that are entirely action-based and reflexive, like muscle memory.

Progressive Disclosure

Instead of dumping a massive analysis result on a human (HITL) all at once and breaking the Context Wall illusion (drowning the user in information), this is when agents present information step by step, through an interface that only expands as needed.

It's usually done with Artifacts or Walkthrough documents. It's a critical UX principle that reduces the cognitive load on a human auditing (Observe) the system.

project-context.md

This is the static orientation file at a project's root directory that summarizes the project's overall state, architecture, directory structure, and what the folders are for, for the agent (LLM) on first entry.

Unlike GEMINI.md (rules) or identity.md (personality) files, it exists entirely to answer "What is this project, what's where?" and keeps the agent from flying blind during the Discover stage.

Prompt Caching

This is a technology where, instead of a model (LLM) re-reading (processing) fixed input that repeats on every request — the giant System Prompt, project-specific rules (AGENTS.md), old logs — it keeps this text in memory (Cache) and only processes the newly added parts.

It's a revolutionary optimization method in agentic systems that cuts Latency and Token Burn Rate (costs) by up to 90%.

Prompt Contract

This is the unwritten agreement between an agent and a developer. It's where the developer rigidly defines, in the main prompt, the specific Output Format they expect from the agent, the Guardrails rules it must follow, and the Tools permissions it will use.

It's backed technically by a Schema Validator and Pydantic. The moment the agent steps outside the contract, an error is thrown (Observe) and the loop is stopped.

Prompt Engineering

Instead of the art of getting the best answer out of a model with magic words, this is the mathematical and structural engineering of designing commands (prompts) — in agentic (Agentic AI) systems — that maximize the model's Reasoning capacity and keep it faithful to a format using Few-Shot Prompting.

In modern systems, it's gradually giving way to autonomous Loop Engineering and dynamic RAG (Context Engineering) designs.

Prompt Tuning

Instead of a developer writing long instructions (Prompt Engineering) every single time, this is optimizing the base LLM model's native language and reflexes for that specific job (e.g., debugging) with low-cost, permanent weight updates (soft tuning or LoRA).

It saves the agent from heavy token costs, letting it operate at enterprise standard even with much smaller prompts inside Fast Mode.

Prompt Injection

This is a cyberattack method where malicious users or manipulative data sources try to trick an agent into breaking its original System Prompt rules.

It's similar to SQL Injection on classic websites; it tries to leak hidden instructions into the agent or get it to run unauthorized commands.

Strict Guardrails and system-level ACL (Access Control List) rules are applied to protect the system against these kinds of attacks.

Prompts (MCP Component)

This is one of the 3 core components (Tools, Resources, Prompts) an MCP Server offers to an agent (Client).

These are pre-built templates that explain how the agent should do a task on that server. The developer doesn't need to write out instructions like "how to search for a customer in Salesforce" for the agent; the MCP Server autonomously hands this standard Prompt (template) to the agent directly during Dynamic Tool Discovery.

Protobuf (.pb)

Instead of sub-components in autonomous agent systems (e.g., Sidecars or Worker Agents) sending massive JSON files back and forth and slowing the system down, this is a messaging standard (gRPC infrastructure) that converts data into a compressed binary format a computer can read much faster.

By solving Latency problems, it becomes the core data carrier for A2A communication in high-performance Agent OS architectures.

Pydantic

This is a validation library that automatically checks the free-form JSON output an agent (LLM) produces against predefined, strict Python classes (data schemas) — and warns the model, forcing a fix, if the wrong type of data comes through (e.g., writing "thirty" instead of an age number).

It takes on the Schema Validator role to guarantee Structured Output and keep the system from breaking during Function Calling.

RAG (Retrieval-Augmented Generation)

This is an "open-book exam" technique that steers a model toward the right answer by pulling relevant information from external data sources (a Vector Database), instead of training the AI model from scratch.

It stops the model from Hallucinating and verifies information through Grounding.

Combined with autonomous loops, it turns into the smarter Agentic RAG structure.

Rate Limiting

This is the shield that stops autonomous agents, when they fall into an uncontrolled infinite loop, from hammering external systems (APIs, databases) or the main LLM Gateway connection thousands of times in seconds — locking it up (DDoS) or burning through the budget.

It works together with Budget Guardrails, keeping the system stable by imposing hardware-level limits on the agent, like "you can make a maximum of 10 requests per minute."

Reach

This is the number of unique people an ad or piece of content reaches. It shouldn't be confused with Impressions; if one person sees an ad 3 times, Reach is 1 and Impressions is 3.

It's the most important KPI metric in brand-awareness campaigns. Detailed Reach reports are provided on the Meta Ads platform.

ReAct (Reasoning + Acting)

This is the core paradigm that separates agents from traditional LLMs that "just think and produce code." It's the flawless, repeating cycle between the Reasoning stage, where the model internally plans and reasons, and the Acting stage, where it directly intervenes in the outside world with Tools.

It's the ancestor of modern Agentic Loop designs, giving an agent the ability to both think like a philosopher and act like a worker.

Reactive Agents

This is a reflexive agent profile that, when a problem comes up, jumps into action instantly, fixes and retries as errors come in, and works on fast reflexes — instead of pulling back to write long Implementation Plan documents like Deliberative (Planner) Agents.

While the risk of mistakes is higher on big architectural designs, they provide unmatched speed for simple code fixes, formatting, and quick lookups (Fast Mode).

Reasoning

This is the "thinking phase" where an AI model builds logical steps in the background and reasons through them before producing an answer.

Instead of jumping straight to an answer and Hallucinating, it breaks the problem into pieces and analyzes it using Chain of Thought (CoT) or Tree of Thoughts (ToT) methods.

It's the bridge between Plan and ACT inside the Agentic Loop.

Red Teaming

This is the process of ruthlessly stress-testing your own supposedly flawless agent system from the inside — by having other agents loaded with Contrarian Agent or Adversary Agent roles attack it — to see whether Prompt Injection holes exist and whether Privilege Boundaries can be broken.

It's the most critical Hard Evals security stage required before an Agentic Engineering architecture can go safely into production.

Redirect

This is when a URL automatically forwards to another URL.
- 301 (Permanent): The page has moved, and SEO strength carries over to the new address.
- 302 (Temporary): The page is temporarily somewhere else, and SEO strength doesn't transfer.

Incorrect redirects cause Crawling errors and lost SEO rankings. Autonomous agents can scan for broken links and bad redirect chains and fix them.

Reducers

In LangGraph or State Graph structures, these are functions that merge multiple pieces of data coming from different Nodes or parallel-running agents (e.g., different design ideas or data batches) into a single, coherent, clean structure (State).

Supporting Memory Consolidation and Curate processes, they prevent wasted agent memory and keep the system from falling into Lost in the Middle syndrome.

Reflective Memory

This is a deep-learning memory where the agent stores the lessons it produces internally (Reasoning) about why it made a past mistake — working like "I tried this code and it crashed because library X was missing, next time install X first."

Where Episodic Memory only keeps "what happened," Reflective Memory keeps "what lesson was learned from it." It's the most valuable type of Knowledge Item (KI) for letting an agent autonomously master its craft (Self-Improvement).

Request Review

In Agentic AI systems, this is the action where an agent pauses the process and requests approval from a human (HITL) or a review from a senior conductor (Orchestrator), either at the end of a task (Definition of Done) or before triggering a dangerous API.

It's the system's safety brake when Always Proceed mode isn't active. A human reviews the code, tells the autonomous agent "fix this part," and sends the agent back to the Observe stage to keep it from making a mistake.

Resolver Agent

Inside a Multi-Agent System (MAS), this is a specialist (worker) agent with strong problem-solving skills, focused purely on fixing a bug or a broken build, instead of writing new code.

For example, if the Implementer agent's code doesn't compile, the Conductor doesn't step in — instead, the Resolver agent is called directly through A2A (Agent-to-Agent) communication. The Resolver analyzes the error, applies the patch, and gets the system back on its feet.

Resources (MCP Component)

This is one of the 3 core components an MCP Server offers to an agent (Client) — the others being Tools and Prompts.

It represents external data sources the agent can only read (read-only), never modify. For example, a database schema, a company's API documentation, or log files are all offered to the agent as a "Resource." By pulling these resources into its Context Window, the agent writes more consistent, grounded code.

Responsive Design

This is a design approach that lets a website automatically adapt and look right across different screen sizes — desktop, tablet, and mobile phone.

It directly affects Core Web Vitals and SEO rankings. Autonomous agents produce responsive code using CSS / HTML / JavaScript and run UI Testing across different screen sizes with a Browser Sub-Agent.

Reverse Prompting

This is a technique where, instead of a human telling the agent what to do, the agent steers or interviews the developer by asking, "What's the best way for me to do this — give me info X and Y."

It's used when requirements are unclear (during the Discover stage). The agent takes the initiative autonomously, filling in the missing pieces of the Prompt Contract with human approval (HITL).

Reviewer Agent

This is an independent quality-control agent built purely for auditing and review, taking on the "Checker" role in the Maker-Checker Architecture model.

When the Implementer Agent finishes its work, it looks at this output with an unbiased eye, analyzing code standards, performance, and security vulnerabilities. If it finds an error, it sends autonomous feedback for a fix; if it approves, the code gets merged.

Robots.txt

This is the directive file, sitting in a website's root directory, that tells search engine bots (Googlebot) which pages to crawl (Crawling) and which to skip.

Misconfiguring it can leave important pages out of Indexing. It works together with the Sitemap. Autonomous agents can analyze robots.txt errors and suggest fixes.

Runtime

Unlike the static moments when code or an agent sits frozen and waiting, this is the dynamic, live execution period when the system is actively processing data, making decisions, and running Tools.

The agent's memory (Working Memory) is active for this entire period. Unexpected errors or Latency issues that come up during Runtime can only be overcome with a strong Agent OS and a flexible Fallback Strategy.

Sandbox

These are fully isolated virtual working cells set up to keep the raw code autonomous agents run through CLI Tools from leaking into and damaging the user's host operating system.

They're provided through nsjail (Linux), sandbox-exec (macOS), or Docker containers. Backed by an ACL (Access Control List), an agent falling into an infinite loop or deleting the system is restricted at the hardware level. It's the common name for the Execution Environment concept.

sandbox-exec (Seatbelt)

This is an isolation (Sandbox) mechanism specific to Apple (macOS) systems that restricts, at the kernel level, the terminal commands an agent runs from reaching OS folders (e.g., Documents, Desktop) or network ports.

It's the Mac equivalent of the nsjail tool on Linux. In Agentic IDE systems, it's an ACL barrier that uses hardware-level force to stop an agent from accidentally wiping your local machine.

Scheduled Tasks

This is scheduling infrastructure that lets agents wake up at set intervals (e.g., every hour, every night) and carry out autonomous tasks independently of a human. Also known as Cron.

It's managed at the Agent OS level. Working integrated with Daemon (background) services, it enables jobs like campaign updates, backups, or system maintenance to run autonomously, 24/7.

Schema Markup

This is code, in machine-readable JSON-LD format, that tells Google what your page's content actually is (a product, a recipe, an FAQ, an event, a business, etc.).

It's what makes "rich results" (Rich Snippets) — star ratings, pricing info, FAQs — show up in search results (SERP). It's a critical component of SEO and GEO (AI search) strategies.

Schema Validator

This is technical shield software (e.g., Pydantic) that autonomously checks, on every operation, whether the Structured Output (structured JSON) an agent produces matches the rule set (schema) the system expects.

If the agent returns text instead of a number for the "Age" field (Hallucination), the Validator instantly throws an error, warns the agent, and gets it to fix its output (Self-Correction) before anything breaks.

SDLC (Software Development Life Cycle)

This covers the entire process from a piece of software's birth (planning) through coding, testing, and going live (Production).

In Agentic Engineering architectures, the goal isn't just to use an agent as a coder — it's to run the entire SDLC cycle end to end autonomously, without human hands, using Planner, Implementer, and Reviewer agents in a Multi-Agent System.

Segmentation Fault

This is when an agent, trying to read an unbounded folder (e.g., `node_modules`), drowns under massive amounts of data, exceeds its Context Window capacity, and the system suddenly crashes (a hard crash).

This hardware-level crash may not even be recoverable at the Agent OS level. To prevent it, blacklist filters like `.antigravityignore` or hardware-level Cost Control Limits must be applied.

Self-Correction

This is an agent's ability to observe an error it hits after an action (ACT) and fix its own code or plan without human intervention.

Unlike traditional software, which crashes the moment it hits an error, this is the greatest strength of autonomous systems.

It works on the Evaluator-Optimizer Pattern and Loop Engineering principles.

Self-Describing API

This is a smart structure where an external application's (API's) own info — "What am I for, and what parameters do you need to write into JSON to pull data from me" — is built right into it as a schema.

Tools offered through an MCP Server are usually Self-Describing. This lets the agent autonomously learn the API's usage manual in seconds during Dynamic Tool Discovery.

Semantic Chunking

This is the process of splitting a massive PDF document or code file into smart pieces while preserving paragraphs' "unity of meaning" (headings, code blocks), instead of splitting by a random word count.

It determines the quality of the data going into a Vector Database. Badly chunked data causes an agent's Agentic RAG searches to turn up irrelevant results (noise) and leads to Lost in the Middle syndrome.

Semantic Memory

This is the library-style memory where an agent stores general facts, definitions, and universal programming standards — things like "the capital of Turkey is Ankara" or "React uses functional components instead of class components."

Unlike experience-based Episodic Memory, it holds objective facts. Global Skills and a base LLM's pre-trained knowledge both fall into this memory type.

Semantic Routing

This is the technology that routes an incoming user request to the most accurate specialist agent by grasping the intent and meaning (Embeddings) behind the text, instead of simple if/else keyword matching.

For example, even if a request like "My site is loading really slowly" doesn't contain the word "speed," the system, via the Orchestrator, autonomously understands this problem belongs to the "Performance and Database Optimization" (Worker Agent) team.

Semantic Search

This is a technique for searching a database (e.g., a Vector Database) based on the mathematical closeness of concepts (Embeddings), rather than exact letter-for-letter word matches.

Search for "dog" and it can find a document about a "Golden Retriever" even if the word "dog" never appears in it. It's the core engine that raises the retrieval quality and Grounding accuracy of Agentic RAG systems to the next level.

Sequential Agents

Inside a Multi-Agent System (MAS), this is a hierarchical model where agents work in sequence, like an assembly line, instead of working fully independently of one another.

For example, Agent A does the research; once it's done, Agent B codes the findings; once that's done, Agent C tests it. Compared to Debate Loops (simultaneous discussion), this gives a more deterministic workflow that's easier to manage (and trace).

Serverless

This is a model where the developer just writes the code and hands it off to a cloud provider (AWS Lambda, Google Cloud Functions), without managing a physical server. The code only runs when triggered, and you're billed only for what you use.

It's ideal for lightweight tasks autonomous agents kick off via Webhook triggers. It's the cloud-based alternative to Daemon processes.

Session

In Google Analytics (GA4), this is the core measurement unit covering the time between a user's arrival on and departure from your site.

Multiple Events (page views, clicks, scrolls) happen within a single Session. A session automatically closes after 30 minutes of inactivity. It's the foundation of Bounce Rate and Conversion Tracking calculations.

Short-Term Memory

This is the "momentary working memory" an agent uses during its currently active task, holding the conversation history and temporary steps.

Unlike Long-Term Memory, it's not permanent — it gets wiped when the Session ends, and its capacity is limited by the Context Window.

Together with Episodic Memory and Working Memory components, it lets the agent do moment-to-moment Reasoning.

Sidecars

These are small microservices that run outside the core Agent OS or Orchestrator, attached to it (like a sidecar motorcycle) but running as their own separate Daemon (background process).

For example, while the main agent writes code, a Sidecar agent might just watch for file changes in a folder (File Watcher) or monitor the system's RAM usage and feed live telemetry data back to the main model.

Simple Reflex Agents

These are the most primitive type of autonomous software — they don't remember the past (no Episodic Memory), don't plan for the future (no Planner capability), and just produce an instant reflexive response to the current situation (input).

They work on logic like "if the temperature goes above 30, turn on the AC." In advanced Agentic AI systems, these agents are used for low-cost routing tasks (Fast Mode).

Sitemap

This is the file that presents search engines with a list of every page on a website in XML format (usually found at `/sitemap.xml`).

It speeds up Google's crawling-based discovery of your site and eases the Indexing process. It's submitted through Google Search Console. Autonomous agents can spot missing pages or errors and update the sitemap.

Skills / Agent Skills

These are standard-format (SKILL.md) instruction manuals that explain "how the work should be done," turning an agent from a dry LLM model into an enterprise-grade worker.

Where Tools provide the physical power to act, Skills are the recipe for what order to use those tools in, with what security standards, and with what architecture (Procedural Memory).

SKILL.md

This is the core skill document, written in YAML metadata (frontmatter) plus Markdown, that explains how agents should do a specific job (e.g., a database migration).

By giving the agent Few-Shot Prompting (example-based guidance), it guarantees the work gets done exactly in the format the developer wants (Structured Output) and follows Guardrails (security) rules.

Slack Integration

This is the integration that lets autonomous agents send task notifications, error reports, and status updates to the Slack team-communication platform.

It's one of the channels of the Notification System. It connects via Webhook or an MCP Server. Autonomous agents can send an automatic alert to Slack when Campaign Syncing finishes or when Budget Guardrails are exceeded.

Slash Commands

These are keyboard shortcuts built to let users quickly trigger the autonomous agent ecosystem through the interface (e.g., `/plan`, `/execute`).

Instead of writing out long Prompt Engineering, they drop the agent straight into a specific workflow. Especially on Agentic IDE platforms, they're the most practical way to put agents into a specific mode (e.g., test-writing mode).

Smart Voice Transcription

This is the technology that lets a developer communicate with agents by voice — like talking to a teammate — without using a keyboard, while the system instantly transcribes that voice with high accuracy, using technical terms appropriate to the context, and hands it to the agent.

It lets a human (HITL) quickly explain what they need during the Discover or Plan stages of long, complex projects.

SOP (Standard Operating Procedure)

These are the strict, repeatable work processes an enterprise company or project defines as "this is how we write code here" — the kind of thing an agent needs to know by heart.

Agentic AI systems eliminate human error by reading these SOPs through SKILL.md or GEMINI.md files. It's the core key to getting deterministic, predictable output.

Spark (MCP Host)

This is one of the open-source or proprietary orchestration hosts that easily manages and sets up MCP (Model Context Protocol) servers in the background and puts them at an agent's (Client) service.

It keeps a developer from getting lost in terminal screens; it speeds up the connection infrastructure that lets an agent talk to the outside world through Dynamic Tool Discovery.

Sparse Persistence

This is a strategy where, instead of saving all the meaningless data and temporary logs it produces to permanent memory, an agent writes only the truly important decision moments, errors, and successful strategies sparsely to a database (Mem0, Firestore).

It saves memory to help solve Context Rot and Token Burn Rate problems.

Spreadsheet Automation

This is the process of automating repetitive data processing, reporting, and analysis tasks in Google Sheets or Microsoft Excel.

Autonomous agents can pull Google Analytics (GA4) or Google Ads data and generate automatic reports. They can connect to Google Sheets through an MCP Server and autonomously update campaign performance tables.

SQL

This is the standard programming language (Structured Query Language) used to query, insert, and update data in relational databases (MySQL, PostgreSQL).

Autonomous agents can run database queries with CLI Tools. Using SQL on BigQuery, they can run deep analysis on raw Google Analytics (GA4) data. It's the structural alternative to NoSQL databases.

SSL Certificate

This is the digital security document that encrypts a website's communication with a user and provides a secure connection (HTTPS), shown with a "lock" icon in the browser.

It's an SEO ranking factor; sites without SSL (HTTP) get flagged as "Not Secure" by Google. It's a mandatory part of Domain configuration.

State Graph

This is the method of building agents' workflows, on platforms like LangGraph, as a visual logic graph made of Nodes and connections (Edges), instead of text blocks where steps proceed randomly.

It makes tracking which stage the system is in (State Tracking) mathematical, and makes rolling back to the start after an error autonomous and controlled.

State Management

This is when an agent (or a swarm of agents) securely saves and manages its current progress, variables, and results (State) while carrying out a long-running task.

If the State is lost, the agent suffers the Goldfish Memory Problem and forgets what it was doing. In State Graph structures especially, it ensures data is passed on completely as it moves from one node to the next.

State Tracking

This is the mechanism by which the Orchestrator monitors, through a dashboard or a JSON object, exactly which stage each of the dozens of Worker Agents below it is at, and who's succeeding versus stuck in an infinite loop.

It's the observation stage that prevents chaos in large Multi-Agent System operations, checking whether work has hit Definition of Done.

State Verification

This is when an agent, after carrying out an action (ACT) or updating a database, fires off a second confirmation query — "Did this actually happen?" — to prove the system's current state.

Not trusting an agent that says "Done" through Hallucination is the foundation of autonomous system security. It's the logical validation step of the Maker-Checker Architecture model.

state.vscdb

Especially in VSCode and Agentic IDE derivatives, this is the temporary SQLite (or JSON)-based system file that holds the IDE's and agent's local session state, open tabs, and interface settings.

If it gets corrupted, an agent's Working Memory context can be damaged, but it usually doesn't leave permanent damage on Long-Term Memory.

Static Context

This is the method of piling an entire project, or massive library documents, into the Context Window right from the start — whether or not the agent will actually use them.

While this approach works on small projects, on large ones it slows the agent down (Latency) and causes it to get stuck on unnecessary data, triggering Lost in the Middle syndrome. The fix is Dynamic Context (Lazy Loading) architectures.

Stochastic Multi-Agent Consensus

This is the process where AI models carrying randomness and probability (Stochasticity) produce different decisions inside Debate Loops, argue with each other, and eventually reach a shared consensus on the correct answer (or code).

It lets a wrong decision a single model might make (Hallucination) get filtered and purified through the multi-agent system's autonomous critique process.

Stochasticity

This is LLMs' nature of not answering the same question (the same input) with the exact same words every single time — being probabilistic and variable, depending on the Temperature setting of generation.

It's an advantage in creative work, but dangerous in coding tasks, like software, that need determinism. JSON Validation and Guardrails are used to help agents get past this randomness.

Structured Output

This is when an agent produces output in a machine-readable, parseable format directly usable for Function Calling (e.g., JSON, XML), instead of returning plain text like it's writing a story.

With its structure guaranteed by a Schema Validator (Pydantic, etc.), this output is mandatory for agents to be able to trigger external systems and APIs.

Subagent

In Multi-Agent System architecture, this is a narrowly-authorized agent created or called — usually by the Conductor — to carry out a specific sub-task (e.g., only browsing the web, or only writing CSS).

It keeps the main agent's memory (Context Window) from filling up with unnecessary detail. When its job is done, it reports the result it got (e.g., a Browser Sub-Agent recording a video) back up and shuts down.

Swarms

This is a Decentralized Agent Networks model where large numbers of lightweight, fast AI agents — usually built as Reactive Agents — come together with simple rules (A2A), like a swarm of bees or ants in nature, and solve a complex problem without a central dictator (Orchestrator).

System Prompt

This is the "master system instruction" that defines an agent's identity, role, permissions, and the core constitution it must follow.

Unlike the instant chat messages a user types, it's the main framework the agent must stay faithful to for its entire working life.

It should be protected with Guardrails against malicious Prompt Injection attempts.

System Thinker

Unlike visionless agents that only write the small piece of code in front of them (Doer/Executor), this is a strategically-thinking agent profile (usually a Conductor or Planner) that has command of the whole project, its architecture, performance metrics, and Clean Architecture rules.

Task Artifact

This is a visual document (Artifact) agents keep and present to a human, in a structured format (Markdown, table), recording which tasks are done, which are in progress (a checklist), and which decisions have been made (status updates) — so they don't get lost during long-running work or projects.

It makes it easier for us to observe the agent's progress.

Task Plan (task.md)

This is the reference (to-do) document a Planner Agent creates to reach the main goal, laying out step by step which Tools to use and which Subagent to assign.

It's the autonomous system's route. Agents keep updating this file throughout the loop to check whether the system has reached Definition of Done.

Technical Debt

This is a buildup of bad (spaghetti) code that violates Clean Architecture rules in favor of a fast fix (a patch), making the project unmanageable down the line.

Pragmatist agents knowingly take on this debt to move faster, while Reviewer Agents constantly work to refactor the code to pay it down, keeping the system from collapsing.

Telegram Bot

This is an automated bot integration used to manage autonomous agents, send commands, and receive notifications through the Telegram messaging platform.

It's one of the Notification System channels. Autonomous agents can send campaign reports to Telegram at intervals set by Cron, or get HITL approval from a user.

Temperature

This is the mathematical hyperparameter that determines how much risk (creativity) an LLM takes when choosing a word — closer to zero produces more deterministic, precise results (lower Stochasticity), closer to one produces more creative, random ones.

In autonomous agents' code-writing tasks, it's usually kept at 0 or very low to minimize Hallucination risk.

Terminal

This is the command-line screen (CLI) where agents send commands directly to servers or a computer and get results back as logs, without using a graphical interface (GUI).

By giving agents direct terminal permission inside an Agentic IDE, they can autonomously carry out physical actions (ACT) like creating folders, compiling, and starting servers within nsjail (Sandbox) boundaries.

Token

This is the basic unit a model (LLM) breaks the text (or code) it reads and produces into for meaning, used to measure billing and capacity (1 Token is usually roughly 3/4 of a word).

In agentic systems, Context Window (memory capacity) and Token Burn Rate (cost/budget) calculations are done entirely in this currency.

Token Burn Rate

This is the amount of Tokens (money) an Agentic AI system — especially multi-agent setups stuck in a loop — burns through per second or minute while operating through an API.

Without being reined in by Cost Control Limits, an agent stuck in an infinite loop can burn through thousands of dollars in tokens by morning. Strategies like Fast Mode and Prompt Caching are used to reduce this fuel consumption.

Tool Operator

In hierarchical systems, this is a narrowly-authorized (Narrow AI) agent that has no direct thinking (Reasoning) or code-writing ability; its only job is to run one specific tool (e.g., only opening a browser, or only triggering an API) on an order from the Orchestrator.

It works like a Subagent. It lightens complex systems and enforces separation of duties (Principle of Least Privilege).

Tools

These are the functions that keep an LLM (model) from being trapped in the digital world, letting it physically intervene in the outside world (a database, the terminal, the internet).

They're triggered during the ACT stage of the Agentic Loop process. The model just decides "delete this file" (Reason) — Tools are what actually carry out that action. It's the most fundamental weapon that sets agents apart from classic chatbots (ChatGPT).

Tools (MCP Component)

This is the action-oriented one among the 3 core components an MCP Server offers to an agent (Client) — the others being Resources and Prompts.

It gives the agent capabilities specific to that server (e.g., a "Salesforce_Add_Customer" tool). The moment the agent connects to the server, thanks to Dynamic Tool Discovery, it learns this tool along with its JSON schema (Self-Describing API) and starts using it.

Top-P

This is a mathematical hyperparameter, working together with Temperature, that narrows the probability pool an LLM draws from when choosing a word.

It's kept low in autonomous agents' coding tasks to reduce Hallucination risk and get stricter, more predictable (deterministic) Structured Output.

Trajectory

This is the full route (footprint) and filmstrip of exactly which steps an agent took from start to finish to complete a complex task, which Tools it used in what order, and how it recovered from errors (Self-Correction).

It captures not just the result but the process. Episodic Memory is built directly out of storing these Trajectory records.

Transformer

This is the neural network architecture, invented by Google in 2017, that forms the foundation of every modern LLM model today (OpenAI GPT, Claude, Gemini, DeepSeek).

It uses an "Attention" mechanism to understand text, grasping how the words in a sentence relate to each other. It's the source of Embeddings and Reasoning abilities.

Tree of Thoughts (ToT)

This is a Deep Reasoning architecture used by advanced agentic systems (Deep Reasoning models, etc.) that goes beyond Chain of Thought — building multiple probability branches (a tree) at once while solving a problem, evaluating those branches in parallel, and pruning the ones that hit a dead end.

It enables error-free decision-making on mathematical and complex software-architecture tasks.

TUI (Terminal User Interface)

This is the graphical interface agents present in the terminal or command line, instead of a web browser (GUI).

Developers often prefer the TUI environment to manage an agent directly with the keyboard (e.g., Slash Commands), read Walkthrough documents, and give Interactive Approvals, instead of using heavy web panels. It provides speed and simplicity.

User Memory

This is a Long-Term Memory unit where an agent stores not just the current project, but "the user's personal preferences" directly (e.g., "Oğuzhan likes dark mode, and always wants me to use Tailwind in code").

It's managed with systems like Mem0. It lets the agent offer a personalized, user-specific experience in every new session.

User Override

This is when a human steps in (HITL) and directly overrides a decision or piece of code the autonomous agent produced inside the Agentic Loop, saying "No, do it this way instead" — intervening directly in the process.

The agent detects this intervention during the Observe stage, changes course, and records it in Reflective Memory so it doesn't repeat the same mistake.

Utility-Based Optimization

This is the logic where an agent, when deciding on an action, doesn't just follow the rules — it mathematically picks the most profitable option by weighing the decision's cost (Token Burn Rate), speed (Latency), and success rate (benefit/cost).

It's used often, especially by finance and ad-optimization agents (ROAS).

UI Testing

This is when agents like a Browser Sub-Agent autonomously test the interface of a website they've written or changed (buttons, menus, colors) down to the pixel, using Vision ability.

It doesn't just check whether the code compiles — it checks whether the screen a human sees is actually designed correctly.

Vector Database

Unlike classic SQL databases, this is a next-generation database type where text and code are stored as mathematical numbers with hundreds of dimensions (Embeddings) — e.g., Pinecone, Chroma.

It makes it possible to search by "meaning" rather than by letters (Semantic Search). It's the heart of RAG (Retrieval-Augmented Generation) architectures.

Verify

This is a logical check-up process inside the Agentic Loop's Observe stage. When an agent writes code, this is where it verifies not just that the code "runs," but that it actually passes the tests in the Definition of Done criteria.

In the Maker-Checker Architecture model, the Reviewer Agent does this verification.

Vibe Coding

This is the practice of producing random code purely by chatting with AI, without writing any software architecture, rule set, or rigorous tests (Evals).

While fun for quick prototyping, it creates fragile, unmaintainable systems in enterprise production environments.

The antidote is the Agentic Engineering discipline, with its rigorous engineering rules.

Video-to-Action Pipeline

This is the process where an agent like a Browser Sub-Agent watches the screen (or a video stream) with a Vision model before acting on a website, understanding button and menu positions in seconds and autonomously deciding what to click and which forms to fill in.

It removes the dependency on DOM (HTML) code, letting the agent navigate the site by actually seeing it, like a human.

Vision

This is an LLM's ability to go beyond just reading text and actually see and analyze photos, screenshots, or designs it's given, like a human would.

It's the foundation of autonomous tasks that need visual intelligence, like UI Testing and Browser Sub-Agent navigation.

Walkthrough

This is the structured (Artifact) report an agent presents to the end user (a human) after finishing a big task, summarizing step by step what it changed, which errors it fixed, and how the new architecture works.

It's written using Progressive Disclosure logic. It lets a human grasp the entire Trajectory without reading the code line by line.

Web Scraper Tool

This is a dedicated external tool that reads the raw HTML from live websites and runs it through a Curate process, turning it into clean Markdown or JSON an LLM can read.

It's the biggest weapon Worker Agent units have for gathering fresh data (e.g., competitor prices) during Agentic RAG workflows.

WhatsApp Business API

This is the official programming interface that lets businesses automatically message customers, send notifications, and provide support over WhatsApp.

It's used as a Notification System and lead-generation channel. Autonomous agents can autonomously send order confirmations, appointment reminders, and similar messages through Webhook triggers.

Worker Agent

Inside a Multi-Agent System, this is a specialist agent that takes orders from the top-level Orchestrator or Planner agent and actually carries out a specific task (e.g., only writing code, only pulling data).

It takes on the "Maker" role in the Maker-Checker Architecture model. When its job is done, it presents a Walkthrough and wraps up its task.

Workflows

This is when agents autonomously carry out a complex task through precise, pre-designed steps (Nodes and Edges) and a set route (State Graph) on systems like LangGraph, instead of random loops.

It prevents infinite-loop spirals and ensures deterministic results that meet Governance standards.

Working Memory

This is the RAM-like memory space, short-term, that an agent (model) is actively working with in the currently open session (or terminal tabs).

This memory evaporates the moment the session closes. It's subject to Context Window limits. Important data the agent needs to remember later must be moved from here into Long-Term Memory through Memory Consolidation.

Workspace Rules

These are local instructions — found only at the root of the specific project being worked on (e.g., in `.agents` or `GEMINI.md`) — holding strict rules like "architecture, style, permissions" specific to that project.

The agent reads these rules first during the Discover stage. They take priority over Global Skills (general-purpose capabilities) and prevent cross-project contamination.

YAML Frontmatter

This is the machine-friendly header format, usually found at the top of skill files like SKILL.md, written between two `---` lines, that instantly gives the agent metadata like "What is this skill called, what does it do?"

Without needing to read the entire text, an agent can make Semantic Routing decisions in milliseconds using this JSON/YAML data.

Zapier / Make

These are automation platforms that connect different applications (CRM, email, Google Sheets, social media) without code to build automated workflows.

They work through Webhook triggers. They're the no-code alternative to the integrations autonomous agents can do directly through an MCP Server or API. n8n is the open-source rival.

Zero-Shot Prompting

This is when an agent is given a task with a single, bare command — "do this" — with no past reference, training, or example (Few-Shot Prompting) provided at all.

The model acts purely by relying on its own internal Semantic Memory. It's not usually preferred in complex Agentic AI systems because it carries a high risk of Hallucination and wrong formatting.

Iceberg Technique

This is a UX/UI technique where the information or Artifacts interface presented to agents shows only the small piece the user or agent needs "right now" above the waterline, just like an iceberg.

It's the foundation of Progressive Disclosure logic. The deep technical detail underneath (the bottom of the iceberg) only surfaces when the agent hits an error or a human asks for detail — saving Context Window space.

Idempotent

This is the property where an operation an agent carries out during the ACT stage (e.g., clicking a button, writing a database record) doesn't create a new problem or extra data even if the same command runs thousands of times in a row — it gives the same result as the first run.

It's a reliable API design rule that stops an agent stuck in an infinite loop from leaving behind damage that crashes the system, at the hardware level.

Identity Propagation

In Multi-Agent System and Multi-Tenant architectures, this is when a main agent (e.g., for Customer A) hands off a task to a Subagent (Worker Agent), carrying that customer's "access permission / token" info (identity) along with it.

It enforces the Principle of Least Privilege. A Subagent can never use more identity than the parent agent has.

Implementation Plan

This is the engineering (implementation) contract prepared during the Plan stage, usually by Deliberative / Planning Agents, listing out all the architectural detail, the Tools to be used, and the SDLC steps before coding even begins.

Once the agent finishes this plan, it usually requests approval from a human via HITL (Interactive Approvals) and moves to action only after approval.

Implementer Agent

Inside a hierarchical Multi-Agent System, this is a high-muscle specialist agent that doesn't build strategy — it writes the raw code, compiles the system, and triggers APIs, sticking strictly to the Implementation Plan document prepared by the Planner Agent.

It makes up the "Maker" (producer) half of the Maker-Checker Architecture model. When it finishes its work, it submits its output for Reviewer Agent review.

Indexing

This is the process where Google, after discovering a web page through Crawling, analyzes its content and saves it into the search database.

Pages that aren't indexed never show up in search results (SERP). Indexing status can be checked through Google Search Console. Robots.txt and Sitemap files govern this process.

Infinite Loop Mitigation

These are the hardware and software safety mechanisms that stop an autonomous agent from falling into an endless, unproductive loop by stubbornly retrying the same bug it can't solve, burning through system resources (Token Burn Rate).

They include measures like a "maximum 5 tries" limit (Rate Limiting) or "call a human if you loop" (Fallback Strategy).

Interactive Approvals

This is when the system, running in a safe mode (Iterative Mode), freezes an action before carrying out something dangerous during the ACT stage (e.g., deleting a database or making a payment) and waits for an instant "Y/N" (yes/no) approval from a human in the terminal.

It's the interface equivalent of the Request Review process in autonomous systems.

Iterate

This is when an agent, during the final Observe stage of the Agentic Loop process, hits a failure or new data and — instead of ending the loop — updates its route (Trajectory), replans (Plan), and moves back to action.

It's the heart of the Self-Correction mechanism — the agent repeats the process until it succeeds (or hits a limit).

Iterative Mode

Unlike Always Proceed mode, where the agent runs entirely on its own end to end, this is a safe collaboration mode where the agent pauses at every critical stage (planning, coding, testing) to present the process to a human, working with them step by step (iteratively).

It's mandatory in enterprise projects and SDLC processes so a human doesn't lose control (Governance).

Evaluator-Optimizer Pattern

This is an autonomous quality-loop architecture where one agent produces content or code, and a second, auditing agent checks the quality and sends feedback to get the first agent to fix it.

It's built on the Maker-Checker Architecture principle; when a single LLM call can't give a flawless answer in one shot, it perfects the output through Self-Correction.

This pattern is especially preferred for hitting Evals standards and driving errors down to zero in complex systems.

Subagent-Driven Development

This is a software development methodology where a complex project gets broken up by the main conductor (Orchestrator) into small, independent, focused Subagents.

Because each subagent has its own dedicated Context Window space, it keeps the main agent's desk from filling up (Context Rot).

When a task finishes, the subagent's output is checked (Verify) and merged into the main system.

Context Compaction

This is the process of autonomously summarizing past steps, decision history, and tool output into memory during long-running agent sessions, so the Context Window doesn't fill up.

It solves an agent's Lost in the Middle problem and meaningfully cuts Token Burn Rate costs.

It plays a critical role in Working Memory management.

Computer Use / GUI Agent

This is an autonomous interface architecture where an AI agent manages desktop applications not just through text commands or an API, but by reading the screen and using mouse clicks and keyboard input, like a human.

It goes beyond Browser Sub-Agent abilities, carrying out actions at the entire operating-system level.

It analyzes the screen with a Vision model and is used in UI Testing or automating legacy systems.

Tool Calling vs MCP

This is the core mindset difference between two architectural approaches to giving AI function capability.

Traditional Tool Calling calls functions statically written into the codebase, while MCP dynamically discovers tools through a standard plug-and-play server (MCP Server).

MCP offers flexibility and security, while static Tool Calling is preferred for lighter, local operations.

Agent Drift

This is when an agent, over long, multi-step tasks, gradually strays from its original main goal and System Prompt boundaries over time, due to the effects of Context Rot.

This can lead the agent into logical mistakes or an Infinite Loop.

Regular status checks (State Verification) and auditing agents (Reviewer Agent) are used to prevent agent drift.

For every concept defined in this glossary, I’ve written a separate, deeper page — definition, comparison table, real examples, and observations from my own work. You’ll find them all below, sorted by category.

Core Concepts

Comparisons

MCP, Claude Skills and Tools

Automation