Agents Guide

What is an Agent?

A LyDos agent is an autonomous system that performs specialized tasks using AI, planning, and execution engines. Agents combine:

• Multi-step task planning and execution
• Tool invocation (file I/O, web search, API calls, etc.)
• Context awareness and memory
• Error recovery and retry strategies
• Human-in-the-loop feedback mechanisms

LyDos manages 109 agents across 12 categories, each optimized for specific use cases. You can run any agent via the SDK, CLI, or API.

Agent Categories

Security & Vulnerability Detection (28 agents)

Security agents perform vulnerability scanning, dependency auditing, penetration testing, and compliance checks.

Deep Research & Analysis (24 agents)

Research agents gather information from web, academic sources, and trends to synthesize comprehensive reports.

Code Quality & Optimization (31 agents)

Code agents provide review, refactoring, testing, documentation, and performance optimization.

Data Science & Analytics (19 agents)

Data agents handle exploratory analysis, SQL optimization, pipeline design, and statistical modeling.

DevOps & Infrastructure (22 agents)

DevOps agents manage Kubernetes, Terraform, CI/CD pipelines, and container operations.

Running Agents

Via Python SDK

from lydos import LyDos

client = LyDos(api_key="lyd_sk_your_key_here")

# Run agent and get immediate response
result = client.agents.run(
    "security-scanner",
    task="Scan ./src for vulnerabilities",
    params={"depth": "comprehensive", "include_deps": True}
)

print(f"Task ID: {result.task_id}")
print(f"Status: {result.status}")

# Poll for completion
import time
while True:
    task = client.tasks.get(result.task_id)
    if task.status in ["completed", "failed"]:
        print(f"Result: {task.result}")
        break
    time.sleep(2)

Via TypeScript SDK

import { LyDos } from '@lydos/sdk';

const client = new LyDos({ apiKey: process.env.LYDOS_API_KEY! });

// Run agent
const result = await client.agents.run('deep-research', {
  task: 'Research the latest AI agent frameworks',
  params: { depth: 'comprehensive', sources: ['web', 'arxiv'] }
});

console.log(`Task: ${result.task_id}`);

// Poll for result
let task = await client.tasks.get(result.task_id);
while (task.status === 'running' || task.status === 'pending') {
  await new Promise(r => setTimeout(r, 2000));
  task = await client.tasks.get(result.task_id);
}

console.log('Result:', task.result);

Via CLI

# List available agents
lydos agents list

# Get agent details
lydos agents get security-scanner

# Run agent
lydos agent run security-scanner \
  --task "Scan ./src for vulnerabilities" \
  --param depth=comprehensive \
  --param include_deps=true

# Stream results
lydos agent run deep-research \
  --task "Research AI trends" \
  --stream

Via API

curl -X POST https://lydos.ailydian.com/v1/agents/run \
  -H "Authorization: Bearer lyd_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "security-scanner",
    "task": "Scan ./src for vulnerabilities",
    "parameters": {
      "depth": "comprehensive",
      "include_deps": true
    }
  }'

Understanding Agent Parameters

Each agent has specific parameters that control its behavior. Parameters are passed when running the agent.

Common Parameters

Getting Agent Specifications

Before running an agent, check its parameter requirements:

# Get agent details and parameters
agent = client.agents.get("security-scanner")
print(f"Parameters: {agent.parameters}")
print(f"Capabilities: {agent.capabilities}")

# Example output:
# Parameters: {
#   'path': {'type': 'string', 'required': True},
#   'depth': {'type': 'string', 'enum': ['fast', 'standard', 'comprehensive']},
#   'include_deps': {'type': 'boolean', 'default': True}
# }

Polling for Task Results

Agents run asynchronously. Use the task ID to poll for results.

Task Lifecycle

Polling Pattern

import time

# Run agent
result = client.agents.run("deep-research", task="Research X")
task_id = result.task_id

# Poll until completion
max_wait = 600  # 10 minutes
poll_interval = 2  # 2 seconds
elapsed = 0

while elapsed < max_wait:
    task = client.tasks.get(task_id)

    if task.status == "completed":
        print(f"Success! Result: {task.result}")
        break
    elif task.status == "failed":
        print(f"Failed: {task.error_message}")
        break

    print(f"Status: {task.status} ({task.elapsed_seconds}s)")
    time.sleep(poll_interval)
    elapsed += poll_interval
else:
    print("Timeout waiting for task completion")
    client.tasks.cancel(task_id)

Best Practices