Tramontane

The only agent framework with state-of-the-art memory, typed skills, and intelligent model routing.

Mistral-native agent orchestration with 3-tier memory, composable skills, 4-channel retrieval, and GDPR compliance. Built in Orleans, France.

pip install tramontane

Why Tramontane?

Quick Start

import asyncio
from tramontane import Agent, MistralRouter

agent = Agent(
    role="Analyst",
    goal="Analyze market trends",
    backstory="Senior market analyst",
    model="auto",
    budget_eur=0.01,
)

async def main():
    router = MistralRouter()
    result = await agent.run("Analyze the EU AI market", router=router)
    print(f"Model: {result.model_used}, Cost: EUR {result.cost_eur:.4f}")
    print(result.output)

asyncio.run(main())

Memory

3-tier memory: working (always in context), factual (knowledge graph), experiential (self-improvement).

from tramontane import Agent, TramontaneMemory

memory = TramontaneMemory(db_path="memory.db")

agent = Agent(
    role="Gerald",
    goal="Remember everything about clients",
    backstory="Autonomous business agent",
    tramontane_memory=memory,
    memory_tools=True,        # Gets retain/recall/reflect/forget/update tools
    auto_extract_facts=True,  # Auto-extracts facts after every run
    working_memory_blocks=["Goals", "User"],
)

The agent can call retain_memory("Acme Corp prefers React"), recall_memory("What does Acme prefer?"), reflect_on_memory("What patterns have I seen?"), forget_memory(id, "GDPR request"), and update_memory(id, "new info") during execution.

4-channel retrieval: semantic (cosine similarity on mistral-embed vectors) + keyword (FTS5 BM25) + entity (graph traversal) + temporal (recency + frequency). Results fused via Reciprocal Rank Fusion (k=60).

Full memory docs

Skills

Typed, composable, learnable capabilities with profiling and security.

from tramontane import Skill, SkillResult, SkillRegistry, track_skill

class LeadQualifier(Skill):
    name = "lead_qualifier"
    description = "Score B2B leads against ICP"
    triggers = ["qualify", "score lead"]
    preferred_model = "ministral-3b-latest"

    @track_skill  # Auto-logs timing, cost, success/failure
    async def execute(self, input_text, context=None):
        from tramontane import Agent
        agent = Agent(role="Qualifier", goal="Score leads", backstory="Sales expert",
                      model=self.preferred_model)
        result = await agent.run(input_text)
        return SkillResult(output=result.output, success=True, cost_eur=result.cost_eur)

registry = SkillRegistry()
registry.register(LeadQualifier())  # SHA-256 hash + security scan
matches = registry.search("qualify this lead")

Includes 5 built-in skills: TextAnalysis, CodeGeneration, EmailDraft, DataExtraction, WebSearch. Supports Python, YAML, and SKILL.md formats. Compose with SkillPipeline, ConditionalSkill, ParallelSkills.

Full skills docs

Tool Calling

async def search_web(query: str) -> str:
    """Search the web for information."""
    return f"Results for: {query}"

agent = Agent(
    role="Researcher",
    goal="Find information",
    backstory="Expert researcher",
    tools=[search_web],
    tool_choice="auto",       # "auto" | "none" | "any" | "required"
    parallel_tool_calls=True,
    max_iter=5,
)
result = await agent.run("Research Mistral AI", router=router)
print(result.tool_calls)

Structured Output

from pydantic import BaseModel

class Analysis(BaseModel):
    summary: str
    score: int
    recommendations: list[str]

agent = Agent(role="Analyst", goal="Analyze", backstory="Expert",
              output_schema=Analysis)
result = await agent.run("Analyze this market")
analysis: Analysis = result.parsed_output  # Validated Pydantic model

Smart Fleet

Reasoning Effort

agent = Agent(model="mistral-small-4", reasoning_effort="high")  # none | medium | high

Progressive Reasoning

agent = Agent(model="mistral-small-4", reasoning_strategy="progressive",
              validate_output=lambda r: "conclusion" in r.output)
# Tries none -> medium -> high, stops at first success

Model Cascading

agent = Agent(model="devstral-small",
              cascade=["devstral-2", "mistral-large-3"],
              validate_output=lambda r: len(r.output) > 1000)

FleetTuner

from tramontane import FleetTuner
tuner = FleetTuner()
result = await tuner.tune(agent, ["prompt1", "prompt2"], optimize_for="balanced")
optimized = result.apply(agent)

Self-Learning Router

from tramontane import MistralRouter, FleetTelemetry
router = MistralRouter(telemetry=FleetTelemetry())
# After 50+ decisions, routes by YOUR production data

Fleet Profiles

from tramontane import FleetProfile
agent = Agent(fleet_profile=FleetProfile.BUDGET)  # BUDGET | BALANCED | QUALITY | UNIFIED

Full fleet docs

Parallel Execution

from tramontane import ParallelGroup
group = ParallelGroup([designer, architect])
result = await group.run(input_text="Design a website")
print(result.get("Designer").output)
print(f"Total: EUR {result.total_cost_eur:.4f}")

Knowledge Bases (RAG)

from tramontane import KnowledgeBase
kb = KnowledgeBase(db_path="knowledge.db")
await kb.ingest(sources=["docs/*.md"])
agent = Agent(role="Support", goal="Help", backstory="Expert", knowledge=kb, knowledge_top_k=5)

Pipeline YAML

name: Lead Gen
budget_eur: 0.01
agents:
  researcher:
    role: Researcher
    model: mistral-small-4
  writer:
    role: Writer
    model: devstral-small
    temperature: 0.8
flow: [researcher, writer]

tramontane run pipeline.yaml --input "Research Scaleway"

Voice Pipelines

from tramontane import VoicePipeline
vpipe = VoicePipeline(agent=my_agent, enable_tts=True)
result = await vpipe.run(text_input="Brief me on today's leads")
# result.audio_bytes = spoken response via Voxtral TTS

Streaming

async for event in agent.run_stream("Generate a report",
    on_pattern={r"## (?P<section>.+)": on_section_found}):
    if event.type == "token":
        print(event.token, end="", flush=True)
    elif event.type == "tool_call":
        print(f"\n[Calling {event.tool_name}]")

GDPR

agent = Agent(role="Processor", goal="Process data", backstory="Expert",
              gdpr_level="strict", audit_actions=True)
# Built-in PII detection, Article 17 erasure, Article 30 reports

The Mistral Fleet

CLI

tramontane models                    # Fleet with pricing + capabilities
tramontane doctor                    # Health check + API connectivity
tramontane fleet                     # Fleet stats from telemetry
tramontane simulate pipeline.yaml    # Cost estimate without API calls
tramontane knowledge ingest docs/    # Build knowledge base
tramontane knowledge search "query"  # Search knowledge base
tramontane telemetry stats           # Router learning metrics

Built With Tramontane

• ArkhosAI — EU answer to Lovable. 4-agent website generator, EUR 0.004/generation.
• Gerald — Autonomous business intelligence agent with memory + skills.

Install

pip install tramontane                # Core
pip install tramontane[redis]         # Redis memory backend
pip install tramontane[postgres]      # PostgreSQL + pgvector
pip install tramontane[voice]         # Voice gateway
pip install tramontane[sandbox]       # E2B code sandbox

Links

• GitHub
• PyPI
• Live Demo
• Docs

License

MIT — Bleucommerce SAS, Orleans, France