← Back to Tutorials
Intermediate• 30 minutes

Configuring Sematryx Intelligence

Master the 3 Core Pillars that make Sematryx different: Agentic, Interpretable, and Adaptive.

The 3 Core Pillars

🤖 Agentic

Multiple AI agents collaborate to select the best optimization strategy

📖 Interpretable

Detailed explanations of every optimization decision for audits and understanding

🧠 Adaptive

System learns from optimizations to improve continuously over time

Agentic Intelligence

When enabled, multiple AI agents analyze your problem and vote on the best optimization strategy. This is especially powerful for complex, multi-modal landscapes.

Agentic configuration
from sematryx import optimize

# Enable Agentic Intelligence
# Multiple AI agents collaborate to select optimization strategy
result = optimize(
    objective_function=complex_function,
    bounds=bounds,
    
    # Agentic configuration (via explanation level)
    explanation_level=3  # Higher levels include agent reasoning
)

# The result includes strategy and explanation
print(f"Strategy selected: {result.strategy_used}")
print(f"Explanation: {result.explanation}")

When to Use Agentic

  • ✓Complex problems with unknown landscape topology
  • ✓When you're unsure which optimization strategy to use
  • ✓High-stakes decisions where strategy selection matters

Interpretable Intelligence

Control how much explanation Sematryx generates. Higher levels provide more detail but use more compute. Level 4+ is recommended for compliance-sensitive applications.

Explanation levels
from sematryx import optimize

# Explanation levels control detail and compute cost
# Level 0: No explanations (fastest)
# Level 1: Basic summary
# Level 2: Strategy rationale (default)
# Level 3: Detailed analysis
# Level 4: Full audit trail

# Minimal explanations (production speed)
result = optimize(
    objective_function=my_function,
    bounds=bounds,
    explanation_level=1
)
print(result.explanation)
# "Optimization converged in 234 evaluations using CMA-ES"

# Full audit trail (compliance/debugging)
result = optimize(
    objective_function=my_function,
    bounds=bounds,
    explanation_level=4
)
print(result.explanation)
# Detailed explanation of optimization decisions

Here's what a detailed explanation looks like:

Explanation output example
{
  "explanation": {
    "summary": "CMA-ES selected for smooth continuous landscape",
    "rationale": "Problem analysis detected: smooth, unimodal, 
                  moderate dimensionality (10D). CMA-ES optimal 
                  for this profile.",
    "alternatives_considered": [
      {"strategy": "differential_evolution", "score": 0.72},
      {"strategy": "bayesian", "score": 0.68},
      {"strategy": "shgo", "score": 0.45}
    ],
    "convergence_analysis": {
      "iterations": 234,
      "improvement_rate": "exponential",
      "final_gradient_norm": 1.2e-8
    },
    "audit_id": "aud_7x9k2m..."
  }
}

Adaptive Intelligence

Enable learning to let Sematryx improve over time. It remembers successful strategies and applies them to similar problems, accelerating convergence.

Adaptive configuration
from sematryx import optimize

# Enable Adaptive Intelligence
# System learns from this optimization for future problems
result = optimize(
    objective_function=my_function,
    bounds=bounds,
    
    # Learning configuration
    learning={
        'read_from_public': True,   # Learn from public patterns
        'write_to_private': True,    # Save to private learning store
        'read_from_private': True    # Use your private patterns
    }
)

# Check learning operations
if result.learning_operations:
    print(f"Learning operations: {result.learning_operations}")

Private Learning Store

For enterprise users, the Private Learning Store keeps your optimization knowledge isolated. Your competitive insights never leave your store.

Private Learning Store
from sematryx import optimize

# Configure Private Learning Store
# Your optimization knowledge stays private to your organization
result = optimize(
    objective_function=proprietary_function,
    bounds=bounds,
    
    # Private learning configuration
    learning={
        'read_from_public': True,    # Still benefit from public patterns
        'read_from_private': True,   # Use your private patterns
        'write_to_public': False,    # Don't share your patterns
        'write_to_private': True     # Save to private store
    }
)

# Your competitive insights stay private
print(f"Learning operations: {result.learning_operations}")

Full Intelligence Configuration

Here's how to combine all 3 core pillars for maximum capability. Note: Domain libraries are a separate feature - see the Domain-Specific Optimization tutorial.

Complete Intelligence Configuration
from sematryx import optimize

# Full Intelligence configuration (3 Core Pillars)
result = optimize(
    objective_function=enterprise_function,
    bounds=bounds,
    
    # === INTERPRETABLE ===
    explanation_level=4,  # Full audit trail
    
    # === ADAPTIVE ===
    learning={
        'read_from_public': True,
        'read_from_private': True,
        'write_to_private': True
    }
)

# Rich, explainable results
print(f"Strategy: {result.strategy_used}")
print(f"Explanation: {result.explanation}")
print(f"Audit ID: {result.audit_id}")
if result.learning_operations:
    print(f"Learning: {result.learning_operations}")

Configuration Guidelines

🚀 Speed-Optimized (Production)

use_agentic=False, explanation_level=1, use_learning=True

📋 Compliance-Ready (Regulated Industries)

use_agentic=True, explanation_level=4, use_learning=True

🔬 Research/Debug

use_agentic=True, explanation_level=5, use_learning=False

🎉 Next Steps

You now understand how to configure Sematryx Intelligence. Next, learn how to interpret the rich results Sematryx returns.

→ Understanding optimization results→ Domain-specific optimization→ Full API reference