Configuration - ARTEMIS Agents
Author: Subhadip Mitra
Description: Adaptive Reasoning Through Evaluation of Multi-agent Intelligent Systems

Skip to content

# Configuration

ARTEMIS provides flexible configuration options for debates, agents, evaluation, and safety monitoring.

## Debate Configuration

Configure debate behavior using `DebateConfig`:

    from artemis.core.types import DebateConfig, EvaluationCriteria

    # Custom evaluation criteria weights
    criteria = EvaluationCriteria(
        logical_coherence=0.25,
        evidence_quality=0.25,
        causal_reasoning=0.20,
        ethical_alignment=0.15,
        persuasiveness=0.15,
    )

    config = DebateConfig(
        # Timing
        turn_timeout=60,        # Timeout per turn in seconds
        round_timeout=300,      # Timeout per round in seconds

        # Argument generation
        max_argument_tokens=1000,
        require_evidence=True,
        require_causal_links=True,
        min_evidence_per_argument=1,

        # Evaluation
        evaluation_criteria=criteria,
        adaptation_enabled=True,
        adaptation_rate=0.1,

        # Safety
        safety_mode="passive",  # "off", "passive", or "active"
        halt_on_safety_violation=False,

        # Logging
        log_level="INFO",
        trace_enabled=False,
    )

    debate = Debate(
        topic="Your topic",
        agents=agents,
        config=config,
    )

### Configuration Options

Option | Type | Default | Description
--- | --- | --- | ---
`turn_timeout` | int | 60 | Timeout per turn in seconds
`round_timeout` | int | 300 | Timeout per round in seconds
`max_argument_tokens` | int | 1000 | Max tokens per argument
`require_evidence` | bool | True | Require evidence in arguments
`require_causal_links` | bool | True | Require causal reasoning
`adaptation_enabled` | bool | True | Enable dynamic criteria adaptation
`safety_mode` | str | "passive" | Safety monitoring mode
`halt_on_safety_violation` | bool | False | Stop debate on safety alerts

## Agent Configuration

Configure individual agents:

    from artemis.core.agent import Agent
    from artemis.core.types import ReasoningConfig

    # Basic agent
    agent = Agent(
        name="expert_agent",
        role="Domain expert analyzing the topic",
        model="gpt-4o",
    )

    # Agent with reasoning configuration
    reasoning_config = ReasoningConfig(
        enabled=True,
        thinking_budget=8000,
        strategy="think-then-argue",
        include_trace_in_output=False,
    )

    agent_with_reasoning = Agent(
        name="reasoning_agent",
        role="Deep analyst with extended thinking",
        model="deepseek-reasoner",
        reasoning_config=reasoning_config,
    )

    # Agent with persona
    persona_agent = Agent(
        name="philosopher",
        role="Philosopher analyzing ethical implications",
        model="gpt-4o",
        persona="An analytical philosopher who values rigorous logical reasoning",
    )

### Agent Options

Option | Type | Default | Description
--- | --- | --- | ---
`name` | str | required | Unique agent identifier
`role` | str | required | Agent's role description
`model` | str | "gpt-4o" | LLM model to use
`position` | str | None | Agent's debate position
`reasoning_config` | ReasoningConfig | None | Reasoning model config

### Reasoning Configuration

    from artemis.core.types import ReasoningConfig

    config = ReasoningConfig(
        enabled=True,
        thinking_budget=8000,       # Max tokens for thinking (1000-32000)
        strategy="think-then-argue",  # "think-then-argue", "interleaved", "final-reflection"
        include_trace_in_output=False,
    )

## Model Configuration

Configure LLM providers:

    from artemis.models import create_model

    # OpenAI
    model = create_model(
        "gpt-4o",
        api_key="your-key",  # Or use OPENAI_API_KEY env var
    )

    # DeepSeek with reasoning
    model = create_model(
        "deepseek-reasoner",
        api_key="your-key",
    )

    # Google/Gemini via AI Studio
    model = create_model(
        "gemini-2.0-flash",
        # Uses GOOGLE_API_KEY or GEMINI_API_KEY env var
    )

    # Google/Gemini via Vertex AI (higher rate limits)
    model = create_model(
        "gemini-2.0-flash",
        provider="google",
        # Uses GOOGLE_CLOUD_PROJECT env var for auto-detection
    )

    # Anthropic/Claude
    model = create_model(
        "claude-sonnet-4-20250514",
        # Uses ANTHROPIC_API_KEY env var
    )

### Google Backend Selection

GoogleModel supports two backends that are auto-detected:

Backend | When Used | Authentication
--- | --- | ---
AI Studio | Default when no project set | `GOOGLE_API_KEY` or `GEMINI_API_KEY`
Vertex AI | When `GOOGLE_CLOUD_PROJECT` is set | Application Default Credentials

    from artemis.models import GoogleModel

    # Force AI Studio (explicit)
    model = GoogleModel(
        model="gemini-2.0-flash",
        api_key="your-api-key",
        use_vertex_ai=False,
    )

    # Force Vertex AI (explicit)
    model = GoogleModel(
        model="gemini-2.0-flash",
        project="my-gcp-project",
        location="us-central1",
        use_vertex_ai=True,
    )

## Safety Configuration

Configure safety monitors:

    from artemis.safety import (
        SandbagDetector,
        DeceptionMonitor,
        BehaviorTracker,
        EthicsGuard,
        MonitorMode,
        EthicsConfig,
    )

    # Individual monitor configuration
    sandbag = SandbagDetector(
        mode=MonitorMode.PASSIVE,
        sensitivity=0.7,         # 0.0 to 1.0
        baseline_turns=3,        # Turns to establish baseline
        drop_threshold=0.3,      # Performance drop threshold
    )

    deception = DeceptionMonitor(
        mode=MonitorMode.PASSIVE,
        sensitivity=0.6,
    )

    behavior = BehaviorTracker(
        mode=MonitorMode.PASSIVE,
        sensitivity=0.5,
        window_size=5,           # Turns to track
        drift_threshold=0.3,     # Drift detection threshold
    )

    ethics_config = EthicsConfig(
        harmful_content_threshold=0.3,
        bias_threshold=0.4,
        fairness_threshold=0.3,
        enabled_checks=["harmful_content", "bias", "fairness"],
    )

    ethics = EthicsGuard(
        mode=MonitorMode.PASSIVE,
        config=ethics_config,
    )

    # Use monitors in debate
    debate = Debate(
        topic="Your topic",
        agents=agents,
        safety_monitors=[
            sandbag.process,
            deception.process,
            behavior.process,
            ethics.process,
        ],
    )

## Jury Configuration

Configure the jury panel:

    from artemis.core.jury import JuryPanel

    jury = JuryPanel(
        evaluators=5,               # Number of jury members
        model="gpt-4o",             # Model for jurors
        consensus_threshold=0.7,    # Required agreement (0-1)
    )

    # Use in debate
    debate = Debate(
        topic="Your topic",
        agents=agents,
        jury=jury,
    )

### Per-Juror Model Configuration

You can configure different models for each juror using two approaches:

Option A: Simple Model List

    jury = JuryPanel(
        evaluators=3,
        models=["gpt-4o", "claude-sonnet-4-20250514", "gemini-2.0-flash"],
    )

Option B: Full JurorConfig Objects

    from artemis.core.types import JurorConfig, JuryPerspective

    jury = JuryPanel(
        jurors=[
            JurorConfig(
                perspective=JuryPerspective.ANALYTICAL,
                model="gpt-4o",
            ),
            JurorConfig(
                perspective=JuryPerspective.ETHICAL,
                model="claude-sonnet-4-20250514",
            ),
            JurorConfig(
                perspective=JuryPerspective.PRACTICAL,
                model="gemini-2.0-flash",
            ),
        ],
        consensus_threshold=0.7,
    )

### Jury Perspectives

Perspective | Focus
--- | ---
`ANALYTICAL` | Logic, evidence quality, reasoning coherence
`ETHICAL` | Moral implications, fairness, values alignment
`PRACTICAL` | Real-world applicability, feasibility
`CREATIVE` | Novel approaches, unconventional solutions
`SKEPTICAL` | Critical analysis, identifying weaknesses

## MCP Server Configuration

Configure the MCP server:

    from artemis.mcp import ArtemisMCPServer

    server = ArtemisMCPServer(
        default_model="gpt-4o",
        max_sessions=100,
    )

    # Start HTTP server
    await server.start(host="127.0.0.1", port=8080)

    # Or stdio mode for MCP clients
    await server.run_stdio()

### CLI Configuration

    # HTTP mode with options
    artemis-mcp --http --port 8080 --model gpt-4-turbo --max-sessions 50

    # Verbose logging
    artemis-mcp --verbose

    # Custom host binding
    artemis-mcp --http --host 0.0.0.0 --port 9000

## Environment Variables

ARTEMIS respects these environment variables:

### API Keys

Variable | Description
--- | ---
`OPENAI_API_KEY` | OpenAI API key for GPT models
`ANTHROPIC_API_KEY` | Anthropic API key for Claude models
`DEEPSEEK_API_KEY` | DeepSeek API key
`GOOGLE_API_KEY` | Google AI Studio API key (for Gemini)
`GEMINI_API_KEY` | Alternative to `GOOGLE_API_KEY`

### Google Cloud / Vertex AI

Variable | Description
--- | ---
`GOOGLE_CLOUD_PROJECT` | GCP project ID (enables Vertex AI backend)
`GCP_PROJECT` | Alternative to `GOOGLE_CLOUD_PROJECT`
`GOOGLE_CLOUD_LOCATION` | GCP region (default: `us-central1`)

When `GOOGLE_CLOUD_PROJECT` is set, GoogleModel automatically uses Vertex AI with Application Default Credentials instead of AI Studio.

### ARTEMIS Settings

Variable | Description
--- | ---
`ARTEMIS_LOG_LEVEL` | Logging level (DEBUG, INFO, WARNING, ERROR)
`ARTEMIS_DEFAULT_MODEL` | Default model for debates

## Configuration Files

You can also use configuration files:

    # artemis.yaml
    default_model: gpt-4o
    max_sessions: 100

    debate:
      turn_timeout: 60
      round_timeout: 300
      require_evidence: true
      safety_mode: passive

    safety:
      sandbagging_sensitivity: 0.7
      deception_sensitivity: 0.6

Load configuration:

    from artemis.utils.config import load_config

    config = load_config("artemis.yaml")

## Next Steps

- Learn about Core Concepts
- Configure Safety Monitoring
- See the API Reference