Autonome

Enterprise AI Agent Orchestration for Java/Spring Boot

Autonome is a production-grade framework for building and orchestrating AI agent workflows in Java/Spring applications. Build complex AI-powered systems with type-safety, Spring Boot integration, and enterprise reliability.

---

Why Autonome?

Built for Enterprise Java

• Pure Java/Spring Boot - Integrates seamlessly with your existing infrastructure
• Type-safe workflows - Compile-time checking, no runtime surprises
• Apache Camel native - 300+ enterprise connectors out of the box
• Production-ready - Thread-safe, auditable, scalable

YAML-Driven Workflows

Define complex multi-agent workflows in simple YAML:

id: customer-onboarding
type: sequential
taskDefinitions:
  - id: validate-data
    agentId: validation-agent
    outputKey: validation_result
  
  - id: create-account
    agentId: crm-agent
    condition: "${validation_result == 'valid'}"

Flexible Execution Strategies

• Sequential - Step-by-step workflows
• Parallel - Concurrent task processing
• Conversational - Stateful multi-turn dialogues

Enterprise Ready

• Multi-tenant isolation
• Pluggable context stores (In-Memory, PostgreSQL, Redis)
• Comprehensive logging and audit trails
• Designed for regulated industries (banking, healthcare, insurance)

---

Quick Start

1. Add Dependencies

<dependencies>
    <dependency>
        <groupId>org.autonome</groupId>
        <artifactId>autonome-core</artifactId>
        <version>1.0.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.camel.springboot</groupId>
        <artifactId>camel-spring-boot-starter</artifactId>
        <version>4.2.0</version>
    </dependency>
</dependencies>

2. Create Your First Agent

@Component
public class CustomerValidationAgent implements Agent {
    
    @Override
    public String getName() {
        return "customer-validation-agent";
    }
    
    @Override
    public void handle(Exchange exchange, AgentContext context) {
        String customerId = (String) exchange.getIn().getHeader("customer_id");
        boolean isValid = validateCustomer(customerId);
        exchange.getMessage().setBody(isValid ? "valid" : "invalid");
    }
}

3. Define a Flow

# flows/customer-onboarding.yaml
id: customer-onboarding
name: Customer Onboarding Flow
type: sequential

taskDefinitions:
  - id: validate
    agentId: customer-validation-agent
    input:
      customer_id: "${customer_id}"
    outputKey: validation_result
  
  - id: create-account
    agentId: crm-agent
    condition: "${validation_result == 'valid'}"
    input:
      customer_id: "${customer_id}"
    outputKey: account_id

4. Execute the Flow

@Autowired
private FlowRuntime flowRuntime;

@Autowired
private FlowLoader flowLoader;

public void onboardCustomer(String customerId) {
    Flow flow = flowLoader.loadFromYaml("customer-onboarding.yaml");
    Map<String, Object> input = Map.of("customer_id", customerId);
    
    AgentContext context = flowRuntime.run(
        "tenant-123", 
        "conversation-456", 
        flow, 
        input
    );
    
    String accountId = (String) context.get("account_id");
    System.out.println("Created account: " + accountId);
}

---

Complete Example: AI-Powered Job Matching

See it in action: autonome-community/examples/01-job-match-scoring/

Flow Definition

id: job-match-scoring
type: sequential
description: AI-powered candidate-job match scoring

globals:
  model: claude-3-5-sonnet-20241022
  temperature: 0.3
  max_tokens: 2000

taskDefinitions:
  - id: score-match
    agentId: jobMatchScoringAgent
    input:
      job_data: "${job_data}"
      candidate_data: "${candidate_data}"
    outputKey: match_result

Agent Implementation

@Component
public class JobMatchScoringAgent implements Agent, AgentInitializer {
    
    @Autowired
    @Qualifier("claudeLLMClient")
    private LLMClient llmClient;
    
    @Override
    public void handle(Exchange exchange, AgentContext context) throws Exception {
        Map<String, Object> jobData = (Map) exchange.getIn().getHeader("job_data");
        Map<String, Object> candidateData = (Map) exchange.getIn().getHeader("candidate_data");
        
        String prompt = buildMatchPrompt(jobData, candidateData);
        String response = llmClient.callLLM(prompt, null, config);
        
        Map<String, Object> result = parseMatchResult(response);
        exchange.getMessage().setBody(result);
    }
}

REST API

@PostMapping("/api/demo/job-match")
public ResponseEntity<Map<String, Object>> scoreMatch(@RequestBody Map<String, Object> request) {
    Flow flow = flowLoader.loadFromYaml("job-match-scoring.flow.yaml");
    AgentContext context = flowRuntime.run("demo", conversationId, flow, request);
    return ResponseEntity.ok(Map.of("result", context.get("match_result")));
}

Test It

curl -X POST http://localhost:8080/api/demo/job-match \
  -H "Content-Type: application/json" \
  -d '{
    "job_data": {
      "title": "Senior Java Developer",
      "required_skills": "Java, Spring Boot, Microservices"
    },
    "candidate_data": {
      "name": "Jane Smith",
      "skills": "Java, Spring Boot, AWS, Kubernetes"
    }
  }'

Response

{
  "success": true,
  "result": {
    "total_score": 92,
    "strengths": [
      "Strong Java and Spring Boot expertise",
      "Relevant cloud-native experience",
      "Leadership capabilities"
    ],
    "recommendation": "hire",
    "summary": "Excellent technical fit with strong Java/Spring background..."
  }
}

---

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    YAML Flow Definition                      │
│  (Sequential | Parallel | Conversational)                   │
└────────────────────┬────────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                     FlowExecutor                             │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  Sequential  │  │   Parallel   │  │Conversational│      │
│  │    Engine    │  │    Engine    │  │    Engine    │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└────────────────────┬────────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                    AgentExecutor                             │
│  • Task Input Resolution  • Agent Instantiation             │
│  • Context Management     • Result Storage                  │
└────────────────────┬────────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────────┐
│                   Agent Implementations                      │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │ Built-in     │  │  Custom      │  │  Apache      │      │
│  │ Agents       │  │  Agents      │  │  Camel       │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────────┐
│              Context Store (Pluggable)                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │  In-Memory   │  │  PostgreSQL  │  │   Custom     │      │
│  │  (Default)   │  │  (Opt-in)    │  │  (Redis...)  │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
└─────────────────────────────────────────────────────────────┘

---

Key Features

Multiple Execution Strategies

Sequential Flows

type: sequential
taskDefinitions:
  - id: step1
    agentId: data-loader
  - id: step2
    agentId: data-processor
  - id: step3
    agentId: data-saver

Parallel Processing

type: parallel
taskDefinitions:
  - id: fetch-user-data
    agentId: user-service
  - id: fetch-order-data
    agentId: order-service
  - id: fetch-payment-data
    agentId: payment-service

Conversational Agents

type: conversational
taskDefinitions:
  - id: chat
    agentId: customer-support-agent
    input:
      user_message: "${user_input}"

Conditional Execution

taskDefinitions:
  - id: check-inventory
    agentId: inventory-agent
    outputKey: stock_level
  
  - id: reorder
    agentId: purchase-agent
    condition: "${stock_level < 10}"

Subflow Composition

taskDefinitions:
  - id: validate-order
    flowRef: order-validation-flow
  
  - id: process-payment
    flowRef: payment-flow
    condition: "${validation_passed}"

Enterprise Integration

@Component
public class SalesforceAgent implements Agent {
    
    @Autowired
    private ProducerTemplate camelProducer;
    
    @Override
    public void handle(Exchange exchange, AgentContext context) {
        // Use any of 300+ Camel connectors
        String result = camelProducer.requestBody(
            "salesforce:query?sObjectQuery=SELECT Name FROM Account",
            null,
            String.class
        );
        exchange.getMessage().setBody(result);
    }
}

---

Examples

Autonome Community includes 4 complete examples:

1. Job Match Scoring ✅ Complete & Working

AI-powered candidate evaluation with Claude API

• Location: autonome-community/examples/01-job-match-scoring/
• What it does: Scores candidates against job requirements
• Status: Fully implemented with REST API

2. Resume Analysis Pipeline 📝 Implementation Guide

Multi-step resume parsing, skill extraction, and summarization

• Location: autonome-community/examples/02-resume-analysis/
• What it does: Parse → Extract Skills → Generate Summary
• Status: Flow YAML + step-by-step guide

3. Text Processing Pipeline 📝 Implementation Guide

Generic text cleaning, sentiment analysis, and summarization

• Location: autonome-community/examples/03-text-processing/
• What it does: Clean → Analyze Sentiment → Summarize
• Status: Flow YAML + step-by-step guide

4. Support Ticket Router 📝 Implementation Guide

Intelligent ticket classification, routing, and response generation

• Location: autonome-community/examples/04-support-ticket-router/
• What it does: Classify → Route → Generate Draft Response
• Status: Flow YAML + step-by-step guide

Try the complete example:

cd autonome-community
mvn spring-boot:run
./test-job-match.sh

---

Built-In Agents

Autonome includes production-ready agents:

Agent	Purpose	Use Case
LoadDocAgent	Document loading	Read files for processing
ScanFolderAgent	Directory scanning	Batch file operations
OpenAIEmbeddingAgent	Text embeddings	RAG pipelines, semantic search
JsonBuilderAgent	JSON transformation	Data format conversion

---

Configuration

Basic Configuration

# application.yml
autonome:
  agents:
    path: agents.yaml
  flows:
    dir: flows/
  context:
    store: in-memory  # or 'postgres'

# LLM Configuration
anthropic:
  api:
    key: ${ANTHROPIC_API_KEY}

# Logging
logging:
  level:
    org.autonome: INFO

Agent Definition

# agents.yaml
- agentId: my-custom-agent
  name: My Custom Agent
  systemPrompt: |
    You are an expert at...
  type: java
  config:
    class: com.example.MyCustomAgent
  enabledExtensions: []
  humanInLoopEnabled: false

---

Production Deployment

1. Use PostgreSQL Context Store

autonome:
  context:
    store: postgres

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/autonome
    username: autonome_user
    password: ${DB_PASSWORD}

2. Configure Connection Pooling

spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5

3. Enable Structured Logging

logging:
  level:
    org.autonome: INFO
  file:
    name: /var/log/autonome/app.log

4. Run

java -jar autonome-community-1.0.0.jar

---

Use Cases

Banking & Financial Services

• KYC/AML workflows with audit trails
• Loan processing pipelines
• Fraud detection orchestration

Healthcare

• Patient onboarding flows
• Claims processing automation
• Regulatory compliance checks

E-commerce

• Order fulfillment pipelines
• Inventory management
• Customer support automation

Insurance

• Policy underwriting workflows
• Claims adjudication
• Risk assessment pipelines

Recruiting & HR

• Candidate screening and matching
• Resume parsing and analysis
• Interview scheduling automation

---

Testing

Autonome includes comprehensive test coverage:

# Run all tests
mvn test

# Run specific module
cd autonome-core
mvn test

Test Coverage:

• ✅ Context storage and thread-safety
• ✅ Flow orchestration engines
• ✅ YAML loading and validation
• ✅ Agent lifecycle management
• ✅ Integration tests

---

Module Structure

autonome-parent/
├── autonome-api/          # Core interfaces and contracts
├── autonome-core/         # Engine, executors, built-in agents
└── autonome-community/    # Examples, demos, getting started

autonome-api - Type-safe interfaces for agents, flows, context autonome-core - Execution engines, flow loaders, built-in agents autonome-community - Working examples and implementation guides

---

Community & Support

Getting Help

• 📖 Documentation - Check the /docs folder and example READMEs
• 💬 Discussions - Ask questions on GitHub Discussions
• 🐛 Issues - Report bugs on GitHub Issues

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

• Found a bug? Open an issue
• Have a feature idea? Start a discussion
• Want to contribute code? Submit a pull request

Enterprise Support

Need help implementing Autonome in your organization?

We offer:

• Quick start packages
• Custom agent development
• Enterprise integration consulting
• Performance optimization
• Training and workshops

---

Roadmap

• Enhanced Observability - Distributed tracing, metrics dashboard
• Flow Versioning - Git-based version control for flows
• Visual Flow Builder - Web UI for designing workflows
• More Built-In Agents - Slack, Teams, email connectors
• Python Bridge - Call Python agents from Java workflows
• Kubernetes Operator - Native K8s deployment and scaling

---

License

Apache License 2.0 - See LICENSE for details.

---

Credits

Built for the enterprise Java community.

Core Technologies:

• Spring Boot 3.4+
• Apache Camel 4.2+
• Java 17+

---

Getting Started

# Clone the repository
git clone https://github.com/aibroughttolife/autonome-framework.git

# Build all modules
cd autonome (or parent folder)
mvn clean install

# Run the community examples
cd autonome-community
java -jar target/autonome-community-1.0.0.jar

# Test the Job Match API
./test-job-match.sh

⭐ Star this repo if you find it useful!

---

Ready to build production-grade AI workflows in Java?

Start with the Job Match Scoring example and see Autonome in action.