Bot Velocity logoBot Velocity

Platform

Hybrid RPA and AI Agent Orchestration Platform

Hybrid automation control plane for AI agents and RPA. Code-first and low-code development, unified orchestration, managed Robots, and built-in evaluation.

Architecture

Four components working as one: SDK-CLI for build and publish, Orchestrator for control, Runner as managed robots, and Runtime SDK for in-process telemetry.

Bot Velocity architecture overview showing SDK-CLI, Orchestrator, Runner, and Runtime SDK layers

Clear interfaces between build, control, execution, and instrumentation keep the platform reliable and evolvable.

Layered responsibilities

  • Build and publish with SDK-CLI; orchestrate centrally.
  • Execute on managed robots (Runner) with leases and health.
  • Instrument with Runtime SDK for tracing, memory, and tools.

Core Components

SDK-CLI (`bv`)

Developer Command-Line Interface

The `bv` CLI is the code-first interface for building, testing, and deploying automation packages. For low-code development, Bot Velocity Studio provides a visual workflow designer that publishes to the same orchestrator. Both paths share governance, evaluation, and Robots.

Key Features

  • Project scaffolding with templates
  • Local execution with dev-mode tracing
  • Package building with dependency locking
  • Publishing to Orchestrator
  • Asset and queue management
  • Interactive authentication
Technical details →

Orchestrator

Centralized Control Plane

The Orchestrator is the brain of the platform. It manages job lifecycle, enforces retry policy, persists traces, and orchestrates evaluation. It never executes user code—only governs it.

Key Features

  • Job lifecycle management (create, claim, complete, retry)
  • State machine enforcement
  • Lease-based execution with heartbeat monitoring
  • Dead-letter queue with replay
  • Trace session management & cost aggregation
  • Evaluation pipeline orchestration
  • MCP server gateway
  • Multi-tenant isolation with RBAC
Technical details →

Runner (Robot)

Managed Execution Robot

Runners are managed execution Robots deployed on desktop, server, or container environments. Each Robot polls for jobs, provisions isolated environments, executes automation code, and reports structured results.

Key Features

  • Job polling with atomic lease acquisition
  • Package download and caching
  • Virtual environment isolation
  • Input parameter schema validation
  • Subprocess execution with timeout enforcement
  • Signal handling (STOP, KILL)
  • Structured error classification
  • Heartbeat lease extension
Technical details →

Runtime SDK

In-Process Instrumentation Library

The Runtime SDK is a Python library that runs inside your automation code. It provides access to platform capabilities: tracing, logging, memory, vector store for RAG, file storage, and process invocation.

Key Features

  • Execution context access
  • Structured logging with batched emission
  • Hierarchical span tracing
  • LLM generation spans with token tracking
  • Tool decorator with auto-instrumentation
  • Process-as-tool invocation
  • MCP server tool invocation
  • Memory and vector store access
  • File store, assets, queues
Technical details →

How It Works

Step-by-step flow from code to evaluation with authoritative lifecycle control.

1

Developer Creates Package

  • Author automation in Python
  • Build `.bvpackage` with SDK-CLI
  • Publish to Orchestrator via `bv publish`
2

Orchestrator Receives Job

  • Job via trigger/API/process invocation
  • Validate and store
  • Enter `pending` state
3

Runner Claims Job

  • Polls Orchestrator
  • Atomically claims with lease
  • Downloads package and provisions env
4

Execution

  • Subprocess with Runtime SDK context
  • User code runs with platform access
  • Logs/spans emitted; `call_process` supported
5

Result Submission

  • Runner submits structured result
  • Orchestrator transitions state
  • Evaluation triggered when applicable
6

Evaluation & Retry

  • Regression + policy checks
  • Retry policy for system errors
  • Trace session updated with costs

Execution + Evaluation Loop

Orchestrator controls lifecycle and evaluation. Runner executes deterministically under lease. Runtime SDK streams spans/logs. Evaluation decides promotion or retry based on policy and regression checks.

Leases + heartbeats
Deterministic state transitions
Evaluation gates

Azure-Native Architecture

Built for enterprise cloud deployment

Infrastructure Components

Bot Velocity uses Azure managed services for production deployment:

  • Azure Database for PostgreSQL (Flexible Server)
  • Azure Cache for Redis
  • Azure Blob Storage (file store)
  • Azure Container Apps (Orchestrator, Runner)
  • Azure OpenAI Service (evaluation LLM-judge)
  • Azure Monitor + Application Insights
  • Azure Key Vault integration (roadmap)
  • Azure AD / Entra ID SSO (roadmap)

Deployment Patterns

Fully Managed

Bot Velocity manages all infrastructure; multi-tenant SaaS; fastest time to value.

Private Cloud

Dedicated tenant in Bot Velocity Azure subscription; isolated infra; enterprise SLA.

Customer VPC (Roadmap)

Deploy in customer Azure subscription; customer-managed infra; maximum control and compliance.

View Deployment Guide →

Security & Isolation

Multi-Tenant Isolation

Tenant from URL path; DB isolation by tenant_id; no cross-tenant access; folder-level sub-isolation.

Execution Isolation

Each job in isolated subprocess + virtualenv; no shared state; lease-based ownership prevents conflicts.

Credential Management

Encrypted secrets with Fernet; secrets never cached; robot tokens for prod; JWT for developers.

Audit Logging

All API calls and state transitions logged with principal; configuration changes tracked; retention configurable.

RBAC

Tenant and folder roles; permission-scoped artifacts; logical OR combination of role permissions.

Network Security

API auth required; MCP gateway with auth injection; rate limiting; DDoS protection via Azure Front Door.

View Trust Center →

Built-In Observability

Tracing

  • Hierarchical span trees with parent-child relationships
  • Generation spans with token and cost tracking
  • Cross-process trace stitching; Langfuse-compatible metadata

Logging

  • Structured logs with batched emission
  • Log levels: TRACE, DEBUG, INFO, WARN, ERROR
  • Non-blocking; searchable in Orchestrator UI

Metrics

  • Job duration breakdowns
  • Success/failure rates per process
  • Cost per execution; queue depths; processing rates

Cost Tracking

  • Per-execution token counts
  • Aggregated session costs
  • Model-specific pricing; forecasting and budgeting

Start Building Today

Join teams automating with confidence.

Request Early AccessSchedule Demo