Agents Overview

What are Riven Agents?

Riven Agents are autonomous AI entities that can execute complex tasks using skills, tools, and persistent memory. Unlike simple chatbots, agents can reason about multi-step workflows, interact with external systems, and collaborate with other agents to accomplish goals.

Each agent operates within a secure sandbox and has access to a configurable set of capabilities. Agents can be deployed to your cluster and managed through the Riven platform.

Agent Architecture

The Agent Manager is the central orchestrator responsible for creating, scheduling, and monitoring agents across your infrastructure. Each agent is composed of three core subsystems:

• Memory — Tiered storage (short-term, long-term, shared) that gives agents persistent context across sessions.
• Skills — Composable capabilities that define what an agent can do, from code review to deployment orchestration.
• Tool Access — Connections to external systems via MCP (Model Context Protocol), enabling agents to read files, run commands, query databases, and more.

agent:
  name: release-bot
  model: claude-opus-4-6
  memory:
    short_term: conversation
    long_term: pgvector
    shared: team-knowledge-base
  skills:
    - code-review
    - deploy
    - monitor
  tools:
    - mcp://filesystem
    - mcp://git
    - mcp://kubernetes

Creating an Agent from Scratch

Here is a complete walkthrough for creating and deploying your first agent:

1. Define the agent configuration

agent:
  name: pr-reviewer
  description: "Reviews pull requests for bugs, security issues, and style violations"
  model: claude-opus-4-6
 
  memory:
    short_term:
      backend: conversation
      max_tokens: 32000
    long_term:
      backend: pgvector
      connection: postgresql://agent:secret@db:5432/memory
      embedding_model: text-embedding-3-small
 
  skills:
    - code-review
    - test-runner
 
  tools:
    mcp_servers:
      - name: git
        transport: stdio
      - name: filesystem
        transport: stdio
 
  triggers:
    - type: github_webhook
      event: pull_request.opened
    - type: github_webhook
      event: pull_request.synchronize
 
  permissions:
    github:
      - read:pulls
      - write:reviews
      - read:contents

2. Register and deploy the agent

# Register the agent in the platform
riven agents create --config agents/pr-reviewer/agent.yaml
 
# Deploy the agent to the cluster
riven agents deploy pr-reviewer
 
# Verify the agent is running
riven agents status pr-reviewer

3. Test the agent

# Send a test task to the agent
riven agents run pr-reviewer \
  --input '{"repo": "riven-private/dev-center", "pr_number": 42}'
 
# View the agent's output
riven agents logs pr-reviewer --follow

Agent Lifecycle

Every agent follows a four-stage lifecycle managed by the Agent Manager:

1. Create — Define the agent's identity, model, and initial configuration. The agent is registered in the platform but not yet active.
2. Configure — Attach skills, memory backends, and tool connections. Set resource limits and permissions.
3. Deploy — The agent is deployed to your Kubernetes cluster as a managed workload. It begins accepting tasks.
4. Monitor — Track agent activity, token usage, task completion rates, and error logs through the observability stack.

Multi-Agent Collaboration

Riven supports multi-agent patterns where agents coordinate to accomplish complex workflows. Agents communicate through shared memory and a message bus, enabling patterns such as:

• Supervisor-Worker — A supervisor agent delegates subtasks to specialized worker agents and aggregates results.
• Pipeline — Agents are chained in sequence, each processing the output of the previous agent.
• Peer Review — Multiple agents independently analyze the same input and a consensus mechanism resolves disagreements.

Use Cases

Riven Agents are designed for production engineering workflows. Common use cases include:

• CI/CD Automation — Agents that monitor pull requests, run builds, execute tests, and manage deployments with human-in-the-loop approval gates.
• Code Review — Agents that analyze diffs, check for security vulnerabilities, enforce coding standards, and leave detailed review comments.
• Monitoring & Alerting — Agents that watch metrics and logs, diagnose issues, and either resolve problems autonomously or escalate to on-call engineers with context-rich summaries.