LogoLogo
Visit Contextual.ioSign Up
  • Getting Started
    • Welcome
    • Tour: Hello, AI World!
  • TRAINING
    • Basic Developer Training Course
      • Lesson 1: HTTP Agent Introduction
      • Lesson 2: Logging and Error Handling Basics
      • Lesson 3: Event Processing Agent Introduction
  • Services Catalog
    • What's in the Catalog?
      • Intro Patterns
      • Object Type Bundles
    • Browse by Platform
    • All Intro Patterns
      • Anthropic Claude Image Analysis
      • Mistral AI Prompt and Response
      • xAI Grok Prompt and Response
      • DeepSeek Chat Prompt and Response
      • Qwen Chat Prompt and Response
      • Perplexity AI Search and Response
      • Firecrawl Website Scraper
      • Groq Prompt and Response
      • Nyckel Dog Breed Classification
      • RapidAPI ClassifyAI Text Classification
      • RapidAPI YouTube AI Video Summary
      • UnifyAI Model Comparison
      • WebPilot URL Analysis and Summarization
      • OpenAI Assistants Prompt and Response
      • OpenAI Sync
    • All Prebuilt Solutions
      • Invoice AI
      • Lead Generation Form
    • All Object Type Bundles
      • Work Order Management System ITIL Object Type Bundle
        • Work Order
        • User
        • Role
        • Permission
        • Asset
        • Task
        • Action
        • Attachment
        • Comment
        • Notification
        • Audit Log
        • Service Level Agreement
        • Custom Fields
        • Work Order Template
        • Work Order Transition
        • Escalation Policy
        • Tag
  • Components & Data
    • Object Types
      • Data in Contextual
        • Secrets
        • Validation
        • Versioning
      • Examples
      • Creating an Object Type
      • Object Type Details
        • Definition
        • Data Schema
          • Automatic Record Metadata
          • Generated Values
            • Dates and Times
            • UUIDs
          • Frequently Used Validation
          • Disallowing Null Property Values
          • Disallowing Undefined Properties
          • Secrets
          • AI Assistant
          • ID and PrimaryKey Permanence
        • UI Schemas
        • Features
        • Triggers
        • Actions
        • Audit Trail
        • Versions
        • Templates
        • Records
      • Using Object Types in Flows
      • Records
        • Records and Your Tenant API
        • Record Import
    • Flows
      • Nodes
      • Wires
      • Message Object
      • Flow Editor
        • Basics
        • Saving Changes
        • In-Flow Testing with Debugger
        • Restart Agents to Make Changes Active
        • Config
      • Node Reference
        • Common
          • Log Tap
          • Inject
          • Debug
          • Complete
          • Catch
          • Status
          • Link In
          • Link Call
          • Link Out
          • Comment
        • Event
          • Prepare Event
          • Event Start
          • Event End
          • Event Error
        • Object
          • Search Object
          • Get Object
          • Create Object
          • Patch Object
          • Put Object
          • Delete Object
          • Run Action
        • Request
          • Send to Agent
          • HTTP GET
          • HTTP PATCH
          • HTTP PUT
          • HTTP DELETE
          • HTTP POST
          • GQL
          • Produce Message
        • Function
          • Function
          • Switch
          • Change
          • Range
          • Template
          • Delay
          • Trigger
          • Exec
          • Filter
          • Loop
        • Models
          • ML Predict
        • Network
          • MQTT In
          • MQTT Out
          • HTTP In
          • HTTP Response
          • HTTP Request
          • WebSocket In
          • WebSocket Out
          • TCP In
          • TCP Out
          • TCP Request
          • UDP In
          • UDP Out
        • Sequence
          • Split
          • Join
          • Sort
          • Batch
        • Parser
          • csv
          • html
          • json
          • xml
          • yaml
    • Agents
      • Creating an Agent
      • Types of Agents
        • Event to Flow
        • HTTP to Flow
          • Custom Domains
      • How Agents Work
        • Flow Execution
        • HTTP Load Balancing
        • Event Routing
      • Scale and Performance
        • Flow execution
        • Parallel Instances
        • Event Lag Scaling
        • Compute Threshold Scaling
        • Instance Compute Sizing
      • Agent Details
        • Definition
        • Operations
        • Logs
          • Session Log
          • Message Log
        • Audit Trail
        • Versions
      • Using Agents in Flows
    • Connections
      • Creating a Connection
      • Types of Connections
        • Basic
        • Bearer
        • Client Grant
        • Kafka
        • Password Grant
        • Public
        • Pulsar
      • Using Connections in Flows
    • JWKS Profiles
      • Using JWKS Profiles in Your Solution
  • PATTERNS
    • Solution Architecture
      • Events, Messages, Queues
    • Working with Data
      • Search Object Node & Pagination
      • Message Payload Content - Triggers and Actions
    • Industry Cookbooks
      • Field Services
  • Tenants
    • Tenant Workspace
    • Tenant Logs
      • Contextual Log Query Language (CLQL)
        • String Searches
        • Keyword Searches
        • Advanced Operators
    • Tenant API
      • API Keys
        • API Key Settings
        • API Key Permissions
      • Documentation
  • Release Notes
    • 2024
      • 2024.12.09
Powered by GitBook
On this page

Was this helpful?

  1. Components & Data

Agents

What are Agents?

In Contextual.io, an "agent" refers to the operational deployment of a flow created using the flow editor. Flows are designed sequences of processing steps, triggered either by the receipt of asynchronous events (from object-type triggers or other agents) or by incoming HTTP requests, which you can easily construct and modify within the flow editor. Once a flow is defined, it can be deployed as an agent.

Agents are the dynamic instances that execute the flows. They are designed to operate autonomously and efficiently under varying load conditions. Each agent encapsulates the logic of the flow and handles its execution according to the operational parameters defined during deployment.

Key Features of Agents

  • Deployment: Agents are deployed versions of flows which you can configure and manage. Once a flow is set up in the flow editor, deploying it as an agent takes just a few clicks.

  • Scalability: Agents are highly scalable, supporting both scale-out (increasing the number of agent instances to handle more load) and scale-up (upgrading the size of an individual agent to Small, Medium, or Large to enhance its processing capability). This flexibility allows you to optimize resource usage and cost based on your specific needs.

  • Auto-scaling: Agents can automatically adjust their scale based on operational metrics. You can configure auto-scaling based on CPU utilization or lag (such as topic-lag in event streams), ensuring that agents remain responsive and efficient even under fluctuating loads.

  • Operational Monitoring: Contextual.io provides robust tools for monitoring and diagnosing agents. Developers can access logs specific to each agent, allowing for detailed inspection and troubleshooting of flow executions. This feature is crucial for maintaining the reliability and performance of your applications.

How Agents Work

Agents operate by continuously monitoring for triggers—either from asynchronous events or direct HTTP API calls. When a trigger is detected, the agent processes it according to the sequence of operations defined in the flow. The platform ensures that all operations adhere to the configured scalability and performance settings.

During execution, agents can interact with various external systems and services, making them highly versatile in integrating disparate data sources and performing complex workflows. The real-time monitoring and logging capabilities of agents provide an essential feedback loop for developers, assisting in rapid development cycles and iterative improvements.

Conclusion

In summary, agents are fundamental to the operational efficiency and scalability of applications developed on the Contextual.io platform. They empower developers to build, deploy, and manage high-performance applications with ease, providing the tools necessary for high-level monitoring and management of operational flows. Whether processing large volumes of data or handling intricate integrations, agents in Contextual.io provide a robust, scalable solution for modern application needs.

PreviousyamlNextCreating an Agent

Last updated 1 year ago

Was this helpful?