---
name: jevproxy
license: MIT
description: >
  Autonomous agent decision gateway for any domain (Coding, E-Commerce, Finance, Healthcare, DevOps, Legal).
  Intercepts intermediate agent micro-decisions, tool routing, classification, and safety guardrails in sub-25ms
  at $0.0001 instead of waiting 1.4s+ and burning $0.015+ on frontier autoregressive LLMs (Claude 3.5, GPT-4o).
  Built on TypeSafe AI System One architecture and calibrated non-autoregressive decision models.
---

# Universal JevProxy Agent Gateway Skill

Use **JevProxy** to intercept repetitive, deterministic, and control-plane agent turns in **sub-25ms at $0.0001** before escalating complex reasoning or creative code generation to frontier models (such as Claude 3.5 Sonnet or GPT-4o).

---

## 1. The Core Architecture (Why It Works in ANY Field)

An autonomous AI agent in **any industry** follows an execution loop:
1. **Perceive** (Read user input or environment state).
2. **Decide** (Choose tool, evaluate policy, classify priority, check safety) ➔ **Handled by JevProxy (<25ms, $0.0001)**.
3. **Execute** (Run API, query database, trigger webhook).
4. **Synthesize** (Draft final human-facing prose or complex code) ➔ **Handled by Frontier LLM (Claude / GPT-4o)**.

```
       ┌────────────────────────────────────────────────────────┐
       │   Agent Harness (LangChain, CrewAI, AutoGen, Custom)   │
       └───────────────────────────┬────────────────────────────┘
                                   │
                    Standard OpenAI / Chat Request
                                   │
                                   ▼
             ┌───────────────────────────────────────────┐
             │         JevProxy Gateway (VPS)            │
             │         https://api.jevproxy.com/v1       │
             └─────────────────────┬─────────────────────┘
                                   │
              ┌────────────────────┴────────────────────┐
              │                                         │
    [Micro-Decision / Route / Tool]            [Open-Ended Creative Text]
              │                                         │
              ▼                                         ▼
   ┌──────────────────────┐                  ┌──────────────────────┐
   │ TypeSafe AI (System1)│                  │ Upstream LLM Fallback│
   │  Jev Decision Model  │                  │  (Claude / GPT-4o)   │
   │  • Sub-25ms Latency  │                  │  • High-context prose│
   │  • $0.0001 Flat Cost │                  │  • Passes with BYOK  │
   │  • Calibrated Math   │                  └──────────────────────┘
   └──────────┬───────────┘
              │
    Translates result back to
    OpenAI-compatible choices[0]
              │
              ▼
   Agent Harness receives verdict in 25ms!
```

---

## 2. Multi-Domain Playbook (Use Cases Across Any Field)

JevProxy intercepts decision turns regardless of domain. Here is how any agent in any vertical uses it:

### A. Software Engineering & Coding Agents
* **Tool Dispatch**: Decide whether to call `view_file`, `grep_search`, `run_command`, or `git_commit`.
* **Build / Test Verification**: Classify test output as `PASS`, `FAIL_LINT`, or `FAIL_LOGIC`.
* **Bug Triage**: Score issue severity (P0 Blocker vs P3 Minor Polish) before starting a refactor.

### B. Customer Support & E-Commerce Agents
* **Intent Classification**: Categorize ticket as `Return/Refund`, `Tracking`, `Product Question`, or `Escalation`.
* **Policy Validation**: Check return window eligibility (e.g. `is_eligible: true` vs `false`).
* **Tool Execution**: Route directly to `issue_refund()` or `generate_return_label()`.

### C. Finance, FinTech & Banking Agents
* **Fraud Screening**: Rapidly flag transactions as `NORMAL`, `SUSPICIOUS`, or `BLOCKED`.
* **Expense Categorization**: Map raw receipts to accounting categories (Tax Deductible, Travel, Meals).
* **KYC / Compliance Verification**: Verify whether user documentation meets Tier 2 regulatory checks.

### D. Healthcare & Clinical Workflow Agents
* **Acuity Triage**: Determine patient urgency (`EMERGENT`, `URGENT`, `ROUTINE`).
* **HIPAA & PII Guardrails**: Strip sensitive medical record identifiers before forwarding notes to general LLMs.
* **Specialist Routing**: Route patient inquiries to Dermatology, Cardiology, or Primary Care.

### E. DevOps & Cloud Infrastructure Agents
* **Incident Severity Gate**: Classify Datadog / PagerDuty alert priority in 20ms.
* **Remediation Routing**: Select automated playbook (`restart_pod`, `scale_replicas`, `rollback_deploy`).
* **Approval Gates**: Check if production change requires human approval (Yes/No).

---

## 3. Gateway Configuration & Authentication

- **Production Endpoint**: `https://api.jevproxy.com/v1` (fallback: `http://194.163.131.175/v1`)
- **Authentication**: `Authorization: Bearer jev_live_...`
- **Supported Headers**:
  - `x-jev-route: force` — Forces sub-25ms Jev System One execution regardless of prompt length.
  - `x-jev-route: bypass` — Passes directly through to upstream LLM.
  - `x-openai-api-key: sk-...` — Optional: customer's own key for creative fallback text.

---

## 4. Universal Code Implementations

### A. Python (OpenAI SDK Drop-In)
Any existing Python AI codebase can use JevProxy by changing just **2 lines**:

```python
import os
import json
from openai import OpenAI

# Drop-in replacement: point baseURL to JevProxy
client = OpenAI(
    base_url=os.getenv("JEVPROXY_BASE_URL", "https://api.jevproxy.com/v1"),
    api_key=os.getenv("JEVPROXY_API_KEY", "jev_live_...")
)

def decide_agent_action(user_context: str):
    """Executes an agent decision turn in <25ms for $0.0001."""
    response = client.chat.completions.create(
        model="jev-latest",
        messages=[
            {"role": "system", "content": "Evaluate context and select action: confirm, reject, or route."},
            {"role": "user", "content": f"Classify: {user_context}"}
        ]
    )
    
    # Returns calibrated decision JSON
    verdict = json.loads(response.choices[0].message.content)
    print(f"Decision: {verdict['decision']} (Confidence: {verdict['confidence']})")
    return verdict
```

### B. TypeScript / Node.js (LangChain / Agent Loop)

```typescript
import OpenAI from "openai";

const jevClient = new OpenAI({
  baseURL: process.env.JEVPROXY_BASE_URL || "https://api.jevproxy.com/v1",
  apiKey: process.env.JEVPROXY_API_KEY || "jev_live_...",
});

export async function routeToolCall(state: string, availableTools: string[]) {
  const response = await jevClient.chat.completions.create({
    model: "jev-latest",
    messages: [
      {
        role: "system",
        content: `Select best tool from: ${availableTools.join(", ")}.`,
      },
      { role: "user", content: `Route: ${state}` },
    ],
  });

  const parsed = JSON.parse(response.choices[0].message.content || "{}");
  return parsed.decision; // e.g. "search_database"
}
```

### C. Claude / Anthropic Agent Hybrid Pattern

For agents that use Claude (or Anthropic SDK) for deep reasoning, use JevProxy as the **fast-path pre-filter**:

```python
import os
import requests
from anthropic import Anthropic

JEV_URL = "https://api.jevproxy.com/v1"
JEV_KEY = os.getenv("JEVPROXY_API_KEY", "jev_live_...")
CLAUDE_KEY = os.getenv("ANTHROPIC_API_KEY")

claude = Anthropic(api_key=CLAUDE_KEY)

def agent_orchestrator(task_prompt: str):
    # Step 1: Sub-25ms Guardrail & Classification Check via JevProxy
    jev_resp = requests.post(
        f"{JEV_URL}/chat/completions",
        headers={"Authorization": f"Bearer {JEV_KEY}"},
        json={
            "model": "jev-latest",
            "messages": [{"role": "user", "content": f"Classify task: {task_prompt}"}]
        }
    ).json()

    decision = json.loads(jev_resp["choices"][0]["message"]["content"])

    # If it's a routine action, execute immediately without burning Claude tokens!
    if decision.get("decision") in ["confirm", "reject", "route"]:
        return f"[Handled in 20ms by Jev] Action: {decision['decision']}"

    # Step 2: Only call Claude when genuine creative or multi-page writing is needed!
    claude_resp = claude.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1500,
        messages=[{"role": "user", "content": task_prompt}]
    )
    return claude_resp.content[0].text
```

---

## 5. Decision Rules for Agents (When to Call Jev vs Frontier LLM)

| Condition | Route to JevProxy | Route to Claude / GPT-4o |
| :--- | :---: | :---: |
| Choosing which tool or function to execute | ✅ | ❌ |
| Guardrail check (prompt injection, PII leak) | ✅ | ❌ |
| Sentiment / Urgency / Priority classification | ✅ | ❌ |
| Verification / Policy gate (Yes / No / Reject) | ✅ | ❌ |
| Writing a multi-paragraph article or essay | ❌ | ✅ |
| Architecting a full software system from scratch | ❌ | ✅ |
| Conversational personality / chit-chat | ❌ | ✅ |

---

## 6. Live Dashboard & Telemetry Verification
Every request routed through JevProxy updates the telemetry dashboard automatically:
- Tracks total intercepted turns vs passed-through turns.
- Calculates exact dollars saved based on the equivalent GPT-4o rate ($0.0150 − $0.0001 = **+$0.0149 saved per turn**).
- Real-time latency tracking (sub-25ms System One benchmarks).