Agentic AI Systems

Code execution agents solve tasks by writing programs, running them in an execution environment and using the observed results to choose a next action. Their competence includes inspecting files, handling runtime errors and verifying artifacts, while keeping generated code within explicitly granted filesystem, network and resource permissions.

Computer Use AI operates software through its visible interface by observing screen or browser state and issuing actions such as clicks, typing and navigation. The practitioner connects perception, persistent application state and action execution so an agent can complete and verify tasks in interfaces designed for people.

Deep research agents investigate a question through repeated searching, source inspection and synthesis. They maintain a research objective across multiple steps, follow evidence gaps and assemble an answer whose claims can be traced to consulted sources, with explicit boundaries on scope, time and accessible information.

Text-to-SQL translates a natural-language question into a database query using schema information and the meaning of the request. The practitioner must connect language interpretation to tables, joins, filters and aggregation, then verify that the query answers the intended question within the user's data permissions.

Voice agents conduct spoken interactions while coordinating speech processing, model decisions and tools. They may use an audio-native model or a speech-to-text, language-model and text-to-speech pipeline, but both designs require reliable turn-taking, interruption handling and confirmation of actions that users request by voice.

AI agent design defines how a model observes a task, chooses actions, uses tools and decides when to stop. It turns a broad goal into an executable control structure with state, permissions and feedback, so autonomous decisions can be inspected and evaluated against the intended outcome.

Agent state management keeps the information and execution status needed to continue an agent's work coherently. It covers task progress, messages, tool results, pending decisions and durable checkpoints, allowing a run to pause, recover or resume without losing context or repeating effects unintentionally.

Agentic planning and task decomposition break a goal into actions or subgoals that an agent can execute and revise. The skill includes identifying dependencies, selecting the right level of detail and updating the plan when observations invalidate assumptions, while preserving a clear criterion for completion.

Reflection and self-refinement use feedback on an initial attempt to guide a subsequent attempt. An agent may critique its answer, interpret test results or retain lessons from a failed action, but improvement must be established by checking the revised result against an independent task criterion.

Self-improving agents generate changes to components that govern their own future behavior, such as prompts, code or tool-selection policies. A separate evaluation and acceptance process decides whether a proposed change is useful, making improvement an experimentally tested system modification rather than an agent's claim about itself.

AI guardrails are controls that check or constrain model inputs, outputs and proposed actions against application rules. They can combine deterministic validation, classifiers and review steps, with a defined response to violations, so acceptable behavior is enforced at specific points in an AI workflow.

Agent sandboxing isolates the environment in which an agent executes code or tools, limiting the resources and external systems it can affect. The practitioner configures filesystem, network, process and credential boundaries so untrusted actions have a contained execution scope and can be stopped or discarded.

Human-in-the-Loop AI places a person's judgment at a defined point in an AI process, such as approving an action, resolving ambiguity or correcting a result. The skill is designing an effective decision handoff with relevant evidence, clear authority and reliable continuation after the person responds.

Resource-aware agent optimization allocates model calls, tools and execution time according to task needs and operating constraints. It uses routing, budgets and stopping rules to control the cost and latency of agent behavior while checking that cheaper or shorter paths still meet the required quality.

LangChain is a framework for composing language-model applications from model interfaces, tools and an agent harness. Using it well means configuring the model loop and its surrounding behavior, connecting integrations and validating task outcomes, while understanding which execution and state facilities are supplied by the framework.

LangGraph is an orchestration framework for stateful workflows and agents expressed through nodes, transitions and shared state. It lets a practitioner combine deterministic steps with model decisions, persist progress and interrupt execution for external input, making the control structure of a long-running task explicit.

LlamaIndex is a framework for connecting language-model applications to external data through ingestion, indexing, retrieval and agent workflows. The practitioner uses its data abstractions to preserve document context and build query or tool interfaces, then verifies that retrieved evidence supports the application's answers and actions.

Pydantic AI is an agent framework that connects model interaction with typed dependencies, tools and validated outputs. It helps a practitioner express data contracts in Python and handle validation feedback, while keeping semantic correctness, authorization and application behavior as separate responsibilities beyond satisfying a schema.

Agent memory systems store and retrieve information that may be useful across steps, sessions or tasks. They select what to retain, associate it with the right person or context and supply relevant records later, helping continuity without treating every past statement as a permanent or authoritative fact.

Model Context Protocol is an open protocol for connecting AI applications to tools, resources and reusable prompts exposed by servers. It standardizes discovery and communication across integrations, while the host application remains responsible for deciding what the model may access and when an operation is authorized.

Multi-agent coordination patterns define how several agents divide work, exchange information and transfer control. Common arrangements include a supervisor with workers, sequential handoffs, parallel specialists and reviewer roles. The practitioner selects a topology that matches task dependencies and makes ownership, shared state and final acceptance explicit.

Multi-agent debate asks several model participants to propose answers, examine one another's arguments and revise their positions before a final decision. It is an inference-time technique for exposing alternative reasoning, with value assessed by correctness and evidence quality rather than the participants' eventual agreement.

Multi-agent orchestration implements the execution of tasks involving several agents: dispatching work, tracking dependencies, managing messages and handling completion or failure. It makes coordination operational through durable state, scheduling and conflict policies, so the system can recover and produce a coherent result when participants behave asynchronously.

A2A Protocol standardizes communication between an agent client and an agent service that can perform work. It provides capability discovery, messages, task lifecycle and artifact exchange, allowing separately implemented agents to interact while preserving their own execution logic, authentication requirements and internal state.

LLM function calling lets a model request an application-defined operation by producing a tool name and arguments. The application validates and executes the request, returns a result and continues the interaction, connecting model interpretation to controlled access to data or actions outside the model itself.

Conversational AI supports interaction through a sequence of user and system turns, retaining enough context to interpret follow-up requests and complete useful tasks. The practitioner designs responses, clarification, state and handoff behavior so the conversation remains coherent and connected to actual application outcomes.

Dialogflow is Google's managed platform for building conversational interfaces using language understanding and dialogue configuration. Its ES and CX services have distinct agent models and APIs. Practitioners design supported conversations, connect fulfillment services and test the dialogue behavior appropriate to the selected service and channel.

Dialogue systems model how an interactive conversation progresses toward a task or communicative goal. The skill covers interpreting user acts, tracking dialogue state and choosing the next system action, including intent-and-slot architectures and hybrids that combine explicit conversation policy with generative language models.

LiveKit provides realtime communication infrastructure and an agent framework for audio and video interactions. In voice applications, a practitioner connects users and agent workers through sessions, integrates speech and model components and controls turn-taking, interruption and tool behavior across a streaming conversation.

Rasa is a conversational AI framework for designing task-oriented assistants with explicit dialogue behavior and integrations. Its CALM approach uses language models to interpret conversation while flows govern task execution, allowing practitioners to combine flexible understanding with inspectable business steps and controlled external actions.

Agent frameworks provide reusable software components for model calls, tools, state and execution control. The practitioner selects and configures these components to fit a task, understanding how the framework runs loops, handles failure and exposes observations, while retaining responsibility for application permissions and task quality.

CrewAI is a framework for organizing agents around roles, tasks and a coordinated process. Practitioners define the expected work, available tools and how results pass between participants, then inspect whether the crew completes the task coherently within its execution and resource limits.

Google ADK is a development kit for implementing agents, tools and coordinated workflows in application code. It supplies execution, session and evaluation components so practitioners can build and inspect agent behavior, choosing between model-directed decisions and explicit workflow control for the task at hand.

Microsoft AutoGen and its successor, Microsoft Agent Framework, support applications built from agents and coordinated execution. The skill includes understanding AutoGen's conversational agent abstractions and the successor's explicit workflows and state facilities, while checking migration differences instead of treating the two libraries as interchangeable APIs.

Semantic Kernel is Microsoft's SDK for integrating models and callable application functions into software. Practitioners use its kernel, plugins and model connectors to compose AI functionality with existing services, keeping invocation policy, state and business rules explicit around the model interaction.

Langflow is a visual environment for composing and testing AI application flows from connected components. Practitioners configure models, data access, prompts and tools, inspect intermediate outputs and expose the resulting flow through supported interfaces, while retaining responsibility for credentials, access and production behavior.

Low-Code AI Automation connects model operations with triggers, data transformations and service actions through visual or configuration-driven workflows. The practitioner designs the surrounding process so uncertain model outputs become validated inputs to controlled business steps, with explicit error handling and observable execution.

Microsoft Copilot Studio is a platform for building agents that combine instructions, organizational knowledge and business actions. Practitioners select a supported agent approach, configure integrations and conversation behavior and test how the agent uses data and permissions in the channels where it will be delivered.

n8n is a workflow automation platform that connects triggers, transformations and service operations as nodes. Its AI integrations allow bounded model calls and agent tool use within those workflows. Practitioners configure data flow, credentials and execution recovery so automated effects remain inspectable and repeatable.

Multi-agent systems contain multiple decision-making participants that interact within a shared task or environment. The skill includes defining roles, information exchange and incentives or authority, then evaluating the behavior of the whole system, including cooperation, conflict and failures that arise from interactions between otherwise capable agents.