Skip to content

Dana Recipes - Agent-Native Convergence Patterns

Real-world solutions demonstrating the convergence of AI development assistance with autonomous execution using Dana's agent-native architecture and OpenDXA

Quick Navigation

🚀 Getting Started

🏗️ Convergence Application Patterns

🤖 Multi-Agent Systems

📚 Advanced Agent-Native Convergence Patterns

Recipe Categories

Agent-Native Programming Patterns

Write agents as first-class primitives with context-aware intelligence:

# Traditional approach: Static classes
class CustomerAnalyzer:
    def assess_risk(self, customer):
        return static_analysis(customer)

# Convergence approach: Adaptive agent with context-aware execution
agent CustomerAnalyzer:
    def assess_risk(self, customer):
        # Context-aware execution - same reasoning, different output types
        risk_score: float = reason("assess customer risk", context=customer)
        risk_details: dict = reason("assess customer risk", context=customer)
        return risk_score, risk_details  # Function learns via POET

Data Modeling & Business Logic

Use Dana's agent-native struct system to model your domain clearly and add AI-powered behavior:

struct Customer:
    id: str
    name: str
    email: str
    status: str

def analyze_engagement(customer: Customer) -> str:
    return reason("Analyze customer engagement patterns", context=customer)

# Method syntax sugar makes it natural
customer = Customer(id="C001", name="Alice", email="alice@example.com", status="active")
engagement = customer.analyze_engagement()

See: Structs Cookbook for complete business domain examples

Self-Improving Pipeline Patterns

Compositional operations that optimize themselves through POET:

# Traditional pipeline: Manual orchestration
def process_data(data):
    step1_result = analyze(data)
    step2_result = filter(step1_result) 
    step3_result = transform(step2_result)
    return step3_result

# Convergence pipeline: Self-improving composition
data | analyze | filter | transform  # Each stage learns and optimizes via POET

Context-Aware Execution Patterns

Intelligence that adapts output types based on usage context:

# Same reasoning adapts to what you need
customer_insights: dict = reason("analyze customer behavior", context=customer_data)
customer_score: float = reason("analyze customer behavior", context=customer_data)
customer_report: str = reason("analyze customer behavior", context=customer_data)

AI Integration Patterns

Seamlessly integrate AI reasoning into your application logic using agent-native features:

# Document analysis
def extract_insights(doc: Document) -> dict:
    key_points = reason("Extract key points", context=doc.content)
    sentiment = reason("Analyze sentiment", context=doc.content) 
    return {"points": key_points, "sentiment": sentiment}

# Risk assessment
def assess_portfolio_risk(portfolio: Portfolio) -> str:
    return reason("Assess investment risk", context=portfolio.positions)

Configuration & Error Handling

Build robust, maintainable applications with proper configuration management:

struct AppConfig:
    database_url: str
    api_key: str
    debug_mode: bool

def validate_config(config: AppConfig) -> bool:
    if not config.api_key:
        log("API key is required", level="error")
        return false
    return true

Performance Patterns

Understand Dana's performance characteristics and optimize when needed:

  • Struct Creation: ~0.7x overhead (actually faster than Python dicts!)
  • Method Calls: ~4x overhead (acceptable for added functionality)
  • Field Access: ~9x overhead (cache frequently accessed data)

How to Use These Recipes

1. Start with Your Use Case

Each recipe is self-contained and includes: - Problem Statement: What you're trying to solve - Complete Working Code: Copy-paste ready examples - Explanation: Why the pattern works - Variations: How to adapt for your needs

2. Copy and Adapt

All examples are designed to be: - Copy-paste ready: Working code you can use immediately - Well-documented: Clear explanations of each part - Extensible: Easy to modify for your specific requirements

3. Build on Patterns

Start with simple patterns and combine them: - Use struct patterns for data modeling - Add AI integration for intelligent behavior - Apply configuration patterns for maintainability - Implement error handling for robustness

Recipe Index

Business Applications

Recipe Use Case Complexity
CRM System Customer relationship management Intermediate
Portfolio Manager Financial portfolio analysis Advanced
Order Processing E-commerce order handling Intermediate

Data Processing

Recipe Use Case Complexity
ETL Pipeline Extract, transform, load operations Advanced
Document Analysis AI-powered document processing Intermediate
Data Validation Input validation and cleaning Beginner

System Patterns

Recipe Use Case Complexity
Configuration Management App config and environment handling Intermediate
Error Handling Robust error management Beginner
Performance Optimization Optimizing Dana applications Advanced

Multi-Agent Systems

Recipe Use Case Complexity
Multi-Agent Collaboration A2A and module agent orchestration Advanced
Agent Pool Management Dynamic agent selection Intermediate
Reason Function Integration AI reasoning with agents Intermediate

Integration

Recipe Use Case Complexity
API Clients REST API integration Beginner
MCP Services Model Context Protocol Intermediate
Database Access Database operations Intermediate

Contributing Recipes

Have a useful pattern or example? We'd love to include it!

Recipe Template

Each recipe should include:

  1. Problem Statement - What real-world problem does this solve?
  2. Complete Example - Working, copy-paste ready code
  3. Explanation - Step-by-step breakdown
  4. Variations - Common adaptations
  5. Best Practices - Do's and don'ts
  6. Performance Notes - Any performance considerations

Submission Process

  1. Follow the template structure
  2. Test all code examples
  3. Include clear documentation
  4. Submit via pull request

Getting Help

Quick Reference

Community

Next Steps

  1. Start Simple: Pick a recipe that matches your use case
  2. Experiment: Modify examples to fit your needs
  3. Build: Combine patterns for larger applications
  4. Share: Contribute back patterns you find useful

Ready to build? Start with First Agent or dive into the Structs Cookbook for advanced patterns.

Copyright © 2025 Aitomatic, Inc. Licensed under the MIT License.
https://aitomatic.com