🧠 Autogentic

TestsVersionElixirLicense

Revolutionary effects-first architecture that makes traditional multi-agent systems look primitive.

Autogentic v2.0 is a sophisticated multi-agent system built with Elixir that enables the creation of intelligent, reasoning-capable agents that can coordinate complex workflows, learn from experience, and adapt their behavior over time.

✨ Key Features

🎭 Advanced Effects System

🧠 AI-Powered Reasoning Engine

🤖 Intelligent Agent Framework

🎓 Continuous Learning System

🏗️ Enterprise-Grade Reliability

🚀 Quick Start

Prerequisites

Installation

git clone https://github.com/c-u-l8er/autogentic.git
cd autogentic
mix deps.get

Run Your First Agent

# Start the Autogentic system
iex -S mix

# Create a simple agent
defmodule MyFirstAgent do
  use Autogentic.Agent, name: :my_agent

  agent :my_agent do
    capability [:greeting]
    initial_state :ready
  end

  state :ready do
    # Agent is ready for interactions
  end

  transition from: :ready, to: :ready, when_receives: :hello do
    sequence do
      log(:info, "Hello from Autogentic!")
      put_data(:greetings_count, 1)
      emit_event(:greeting_sent, %{agent: :my_agent})
    end
  end
end

# Start and interact with your agent
{:ok, pid} = MyFirstAgent.start_link()
GenStateMachine.cast(pid, :hello)

📚 Examples

We've created comprehensive examples that demonstrate Autogentic's capabilities across different use cases:

🟢 Basic Examples

🤝 Multi-Agent Coordination

🧠 Advanced Reasoning

🏭 Real-World Applications

Running Examples

# Recommended: Use the example runner (ensures system is properly initialized)
mix run run_example.exs examples/basic/hello_agent.exs
mix run run_example.exs examples/coordination/deployment_team.exs

# Alternative: Run in interactive mode
iex -S mix
iex> c "examples/basic/hello_agent.exs"
iex> HelloAgentExample.run()

# List all available examples
mix run run_example.exs

🎯 Core Concepts

Effects-First Architecture

Autogentic is built around the concept of effects - declarative descriptions of what should happen:

# Simple effect
{:log, :info, "Hello World"}

# Complex workflow
{:sequence, [
  {:put_data, :start_time, DateTime.utc_now()},
  {:parallel, [
    {:delay, 100},
    {:log, :info, "Processing..."},
    {:emit_event, :started, %{}}
  ]},
  {:put_data, :completed, true}
]}

Agent Coordination

Agents communicate through reasoning broadcasts and event emissions:

# Agent A shares insights with Agent B
broadcast_reasoning("Analysis complete", [:agent_b])

# Agent B receives and processes the shared reasoning
behavior :process_shared_reasoning, triggers_on: [:reasoning_shared] do
  sequence do
    log(:info, "Received insight from peer agent")
    put_data(:external_insight_received, true)
    adapt_coordination_strategy(%{collaboration_level: :high})
  end
end

Reasoning Integration

Every agent can perform sophisticated reasoning:

# Start a reasoning session
{:ok, session_id} = Autogentic.start_reasoning("deployment_decision", context)

# Add reasoning steps
step = %{
  question: "Is the system ready for deployment?",
  analysis_type: :assessment,
  context_required: [:system_health, :test_results]
}

{:ok, processed_step} = Autogentic.Reasoning.Engine.add_reasoning_step(session_id, step)

# Get conclusion with confidence score
{:ok, conclusion} = Autogentic.Reasoning.Engine.conclude_reasoning_session(session_id)

🧪 Testing

Autogentic comes with a comprehensive test suite covering all major functionality:

# Run all tests
mix test

# Run with coverage
mix test --cover

# Run specific test categories
mix test test/autogentic/effects/
mix test test/autogentic/reasoning/
mix test test/autogentic/agent/

Current Test Status: 64 tests passing ✅

🏗️ Architecture Overview

┌─────────────────────────────────────────────────────────────────┐
│                        Autogentic v2.0                         │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐ │
│  │   Agent Layer   │  │  Reasoning      │  │   Learning      │ │
│  │                 │  │   Engine        │  │ Coordinator     │ │
│  │ • State Machine │  │ • Multi-Step    │  │ • Pattern       │ │
│  │ • Behaviors     │  │   Analysis      │  │   Storage       │ │
│  │ • Coordination  │  │ • Knowledge     │  │ • Adaptation    │ │
│  │ • Effects       │  │   Base          │  │ • Sharing       │ │
│  └─────────────────┘  └─────────────────┘  └─────────────────┘ │
├─────────────────────────────────────────────────────────────────┤
│                     Effects Engine                              │
│  • Sequence/Parallel/Race Execution • Error Handling           │
│  • Retry/Compensation/Circuit Breaker • Context Management     │
├─────────────────────────────────────────────────────────────────┤
│                   GenStateMachine + OTP                        │
│            Erlang/OTP • Actor Model • Supervision              │
└─────────────────────────────────────────────────────────────────┘

🔧 Configuration

Configure Autogentic in your config/config.exs:

config :autogentic,
  # Effects Engine settings
  effects_timeout: 30_000,
  max_parallel_effects: 100,
  
  # Reasoning Engine settings
  max_reasoning_steps: 20,
  confidence_threshold: 0.6,
  
  # Learning settings
  pattern_storage_enabled: true,
  cross_agent_learning: true,
  
  # Logging
  log_level: :info

🗺️ Roadmap

Phase 1: Production Readiness ⏳

Phase 2: Advanced AI Capabilities ⏳

Phase 3: Enterprise Features ⏳

🤝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Development Setup

# Clone the repository
git clone https://github.com/c-u-l8er/autogentic.git
cd autogentic

# Install dependencies
mix deps.get

# Run tests
mix test

# Run examples
mix run examples/basic/hello_agent.exs

📖 Documentation

💬 Community

📄 License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

🙏 Acknowledgments

Ready to build the future of intelligent systems? 🚀

git clone https://github.com/c-u-l8er/autogentic.git
cd autogentic
mix deps.get
iex -S mix

Welcome to Autogentic v2.0 - where agents think, learn, and collaborate.