Adala

Agents autonomously acquire and refine skills by executing tasks in defined environments, observing outcomes, and reflecting on performance to improve. The learning phase (agent.learn()) orchestrates a feedback loop where the agent applies skills, receives structured feedback from the environment, and uses that feedback to refine skill prompts and execution strategies without manual intervention. This is implemented via a Pydantic-based agent orchestrator that coordinates skill execution, environment interaction, and runtime-based LLM calls to progressively improve task performance.

Skills are organized into SkillSets that define execution patterns: LinearSkillSet chains skills sequentially where each skill's output becomes the next skill's input, while ParallelSkillSet executes multiple skills concurrently and combines their outputs. This composition is implemented via a SkillSet base class that manages skill ordering, data flow between skills, and output aggregation. The runtime system executes each skill through LLM calls, enabling complex multi-step data processing pipelines without custom orchestration code.

Adala includes a prompt improvement skill that uses LLM-based reflection to analyze task failures and suggest prompt refinements. When an agent's skill produces incorrect outputs, the improvement skill examines the failure, generates explanations, and proposes better prompts. This is implemented via a dedicated PromptImprovement skill that calls the LLM with failure analysis prompts. The refined prompts are then tested and validated, creating an automated prompt optimization loop without manual intervention.

Adala agents can be serialized to and deserialized from disk using Python's pickle format or JSON, enabling checkpointing and recovery. Agent state (skills, learned prompts, execution history) is preserved, allowing agents to resume from checkpoints without losing progress. This is implemented via Pydantic model serialization that captures the complete agent configuration and learned state. Serialized agents can be shared, versioned, or deployed across different environments.

Adala provides Docker and Kubernetes deployment guides and configurations for containerizing agents as services. The framework supports building Docker images with agents, deploying to Kubernetes clusters, and managing agent scaling via container orchestration. Integration with ArgoCD enables GitOps-based deployment workflows. The architecture enables agents to be deployed as stateless microservices that scale horizontally based on demand.

Adala includes a testing framework that uses cassette-based mocking (VCR-style) to record and replay LLM API calls, enabling reproducible tests without external API dependencies. Tests can verify agent behavior, skill execution, and learning loops using recorded responses. The framework integrates with pytest and provides fixtures for common testing scenarios. Cassettes capture request/response pairs, enabling deterministic test execution and reducing test costs.

Adala includes GitHub Actions workflows for automated testing, linting, and deployment. The CI/CD pipeline runs tests on pull requests, validates code quality, and deploys agents to production on merge. Workflows are defined in YAML and integrate with the testing framework for reproducible builds. The architecture enables continuous integration and deployment of agents without manual intervention.

The Runtime system provides a unified interface to multiple LLM providers (OpenAI, Anthropic, LiteLLM-compatible services) through a base Runtime class that abstracts provider-specific API calls. Runtimes handle prompt formatting, token management, function calling, and response parsing. The implementation uses LiteLLM as a compatibility layer for provider abstraction, enabling agents to switch between providers via configuration without code changes. Multi-modal support is built in, allowing runtimes to process images alongside text.

Environments provide data and structured feedback to agents through a standardized interface. Environments define what data the agent processes, what feedback signals are available (correctness, error messages, performance metrics), and how to validate agent outputs. The Environment base class abstracts different data sources (databases, files, APIs) and feedback mechanisms (human annotations, automated validators, external services). Agents interact with environments via a standardized get_data() and provide_feedback() pattern, enabling decoupled agent-environment interaction.

Adala provides pre-built Skill implementations for common data labeling tasks: classification (assigning labels to data) and entity extraction (identifying and extracting structured information from text). These skills are implemented as Pydantic models with configurable prompts and output schemas. They execute via the Runtime system, using LLM calls to perform the actual classification or extraction. Skills can be learned (prompts refined) or used directly with static prompts. Output validation ensures extracted entities match expected schemas.

Adala integrates with Label Studio, a popular annotation platform, enabling agents to work alongside human annotators. The integration allows agents to process data, submit predictions to Label Studio, and receive human feedback/corrections. This creates a hybrid workflow where agents handle routine labeling and humans focus on edge cases or quality assurance. The integration is implemented via Label Studio API calls and result handlers that sync agent outputs with the annotation platform.

Adala supports RAG (Retrieval-Augmented Generation) and knowledge-based skills that augment agent decision-making with external knowledge sources. Skills can retrieve relevant context from knowledge bases, documents, or vector stores before making predictions. This is implemented via knowledge retrieval skills that query external sources and pass retrieved context to classification/extraction skills. The architecture enables agents to make more informed decisions by grounding predictions in retrieved knowledge rather than relying solely on LLM parameters.

Adala provides a FastAPI-based server component that exposes agents as HTTP endpoints, enabling remote skill execution and agent interaction. The server handles async request processing, skill execution, and result streaming. It implements request validation, error handling, and logging middleware. The architecture allows agents to be deployed as services that can be called from external applications, enabling integration with existing systems and scaling across multiple instances.

Adala integrates with Apache Kafka for event-driven data processing, enabling agents to consume data from Kafka topics, process it, and publish results to output topics. The integration implements Kafka consumers/producers that handle message serialization, error handling, and offset management. This enables high-throughput, scalable data processing pipelines where agents process streaming data in real-time. Result handlers manage how agent outputs are persisted or forwarded.

Result handlers manage how agent outputs are persisted, routed, or forwarded after execution. Different handler types support various output destinations: database storage, file systems, APIs, message queues, or custom backends. Handlers are pluggable and can be composed, enabling flexible output pipelines. The architecture decouples agent execution from output handling, allowing the same agent to route results to multiple destinations without code changes.