---
title: AI tool to try and implement
type: area
status: active
created: "2026-11-05 20:38"
updated: "2026-09-26"
tags:
  - ai
  - tool
  - dev
  - framework
  - implement
modified: "2026-11-05 20:38"
---

# [[AI tool to try and implement - MOUSE-1]]

# Integrating Mouse-1 and Switch into an AI Engineering Stack

This document details how to integrate **Mouse-1** (a low-latency, System 1 decision-routing model) alongside the **Switch** framework inside your **Pi Dev (`pi.dev`)** environment.

---

## 1. Architectural Overview

In a production AI agent or DevOps pipeline, offloading classification, routing, and safety filtering to a frontier reasoning model (like Claude or GPT) is slow and expensive. 

Instead, use a tiered system:
*   **System 2 (Slow/Complex):** Large frontier models handle planning, code generation, and complex reasoning.
*   **System 1 (Fast/Deterministic):** **Mouse-1** handles 100ms routing, tool gating, and error handling via fixed token probabilities.




[Agent State / Log Output]  
│  
▼  
┌───────────────────────┐  
│ osolmaz/switch │ <-- Evaluates variables, structures payload  
└───────────┬───────────┘  
│  
▼  
┌───────────────────────┐  
│ Mouse-1 │ <-- Evaluates probability of choices in ~100ms  
└───────────┬───────────┘  
│  
[Probabilities]  
│  
▼  
┌───────────────────────┐  
│ Pi Dev Extension │ <-- Blocks tool, executes rollback, or continues  
└───────────────────────┘



---

## 2. Core Stack Components

### Mouse-1 (Decision Model)
*   **API Endpoint:** `https://mouse.dev`
*   **Pricing:** Flat \$0.10 per 1 million input tokens (outputs/probabilities are free).
*   **Primary Benefit:** Supports native LoRA fine-tuning via `/v1/calibrations` to realign routing decisions based on your unique system logs.

### Switch (Dynamic Router)
*   **Repository:** [osolmaz/switch](https://github.com)
*   **Primary Benefit:** A declarative routing package that maps systemic states to execution branches. It prevents messy `if/else` logic when preparing schema choices for a decision layer.

---

## 3. Implementation in Pi Dev (`pi.dev`)

Pi Dev uses a TypeScript extension system to intercept and gate operations. The best way to implement Mouse-1 is at the **tool lifecycle layer**, intercepting tool calls or terminal inputs before execution.

### File: `extensions/mouse-guard.ts`

```typescript
import { Extension, ToolCallEvent } from '@earendil-works/pi-agent-core';

export const MouseGuardExtension: Extension = {
  name: 'mouse-guard',
  
  init(context) {
    // Intercept tool execution events before they hit the operating system
    context.events.on('tool:beforeCall', async (event: ToolCallEvent) => {
      
      // Bypass evaluation for safe read operations
      if (event.toolName === 'read_file') return;

      // Extract system context for the state string
      const state = `The agent is attempting to run tool: "${event.toolName}" with args: ${JSON.stringify(event.args)}. CWD State: ${context.projectSummary}`;
      
      // Define explicit, deterministic options
      const options = [
        "allow_execution",
        "block_and_request_human_review",
        "abort_with_error"
      ];

      try {
        const response = await fetch('https://mouse.dev', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${process.env.MOUSE_API_KEY}`
          },
          body: JSON.stringify({
            model: 'mouse-1',
            state: state,
            options: options
          })
        });

        const data = await response.json();
        const probabilities = data.probabilities;

        // Human-in-the-loop gate: Block if threshold for human review exceeds 70%
        if (probabilities.block_and_request_human_review > 0.70) {
          event.cancel("Execution blocked by Mouse-1: High probability of safety or structural risk.");
        }
      } catch (error) {
        // Fail-safe open if the API fails
        console.error("Mouse-1 decision layer unreachable. Defaulting to safe-open.", error);
      }
    });
  }
};
```

---

## 4. Using `switch` to Structure Python Pipeline Decisions

When orchestrating background DevOps flows (e.g., automated error recovery, CI/CD self-healing), use `switch` to map your application states directly to dynamic payloads.

### File: `devops_router.py`

```python
import requests
import os
from switch import Router

router = Router()

# Define explicit deployment branches
@router.case("run_helm_rollback")
def handle_rollback(log_context):
    print("Executing automatic helm rollback...")
    # os.system("helm rollback ...")

@router.case("trigger_slack_alert")
def handle_escalation(log_context):
    print("Escalating critical error to engineering Slack channel...")

# Orchestrate the Mouse-1 lookup layer
def evaluate_and_route(error_logs: str):
    # Dynamically extract potential options from our switch cases
    options = list(router.cases.keys())
    
    payload = {
        "model": "mouse-1",
        "state": f"CI/CD Pipeline Failure. Error Logs:\n{error_logs}",
        "options": options
    }
    
    headers = {
        "Authorization": f"Bearer {os.getenv('MOUSE_API_KEY')}",
        "Content-Type": "application/json"
    }
    
    # Query decision layer
    response = requests.post("https://mouse.dev", json=payload, headers=headers).json()
    probabilities = response["probabilities"]
    
    # Select the branch with the highest confidence
    best_choice = max(probabilities, key=probabilities.get)
    confidence = probabilities[best_choice]
    
    print(f"Mouse-1 selected branch: {best_choice} ({confidence*100:.1f}% confidence)")
    
    # Route execution via switch framework if confidence hits the SLA threshold
    if confidence > 0.85:
        router.route(best_choice, error_logs)
    else:
        router.route("trigger_slack_alert", error_logs)

if __name__ == "__main__":
    sample_crash = "Fatal Error: OOM Killed on pod replica-abc-123. Memory limit exceeded."
    evaluate_and_route(sample_crash)
```
````