API Reliability RL Agent

A Decision Intelligence System for Smart API Optimization

---

Overview

This project implements a decision intelligence system that optimizes API usage under uncertain conditions using Reinforcement Learning (RL)-inspired logic.

Instead of blindly calling APIs, the system:

• observes current conditions
• selects an action
• evaluates the outcome
• improves decisions over time

Goal: maximize success, minimize latency, and reduce cost

---

Problem Statement

Real-world APIs are unreliable due to:

• ❌ Failures
• ⏱️ High latency
• 💸 Cost constraints
• ⚡ System load fluctuations

Traditional systems use fixed rules, which are inefficient.

This project builds a dynamic decision engine that adapts in real time.

---

Core Concept

The system follows a Reinforcement Learning loop:

State → Action → Reward → Next State

---

📌 State (Observation)

Each API call produces:

• api_status → success / failed
• latency → response time
• retry_count → retries attempted
• api_cost → cost incurred
• system_load → low / medium / high

---

🎯 Actions

The agent can choose:

Action	Description
accept	Accept current response
retry	Retry API call
switch_api	Switch to alternative API
use_cache	Use cached response
return_error	Stop and return failure

---

🏆 Reward System

Each action is evaluated with a reward (0–1):

✔️ Positive factors

• successful API call
• low latency
• minimal retries
• low cost

❌ Penalties

• excessive retries
• high latency
• unnecessary switching

---

🧠 Agent Behavior

The system learns decision patterns such as:

failed + low retries → retry  
success + low latency → accept  
too many retries → switch_api  
high load → use_cache  

👉 It balances performance, cost, and reliability.

---

🏗️ Architecture

Evaluator / User
        ↓
Inference Script (Agent)
        ↓
API Calls (/reset, /step)
        ↓
FastAPI Backend
        ↓
Environment Logic
        ↓
Reward + Next State

---

📂 Project Structure

api-reliability-rl-agent/
│
├── inference.py            # Agent logic + evaluation loop
├── models.py               # Typed models
├── openenv.yaml            # OpenEnv configuration
├── pyproject.toml
├── uv.lock
├── requirements.txt
├── Dockerfile
│
├── server/
│   ├── app.py              # FastAPI backend
│   └── environment.py      # RL environment logic
│
└── app.py                  # (Optional) Gradio UI

---

🔌 API Endpoints

🔹 Health Check

GET /

Response:

{"status": "ok"}

---

🔹 Reset Environment

POST /reset

Request:

{
  "difficulty": "easy"
}

👉 Initializes new episode 👉 Reward = 0 (no action yet)

---

🔹 Step (Execute Action)

POST /step

Request:

{
  "action": {
    "action": "retry"
  }
}

Response:

{
  "observation": {...},
  "reward": 0.83,
  "done": false
}

👉 Applies action and returns reward

---

⚠️ Important Clarification

👉 The API does NOT decide actions

/step = executor only

👉 YOU provide action → system evaluates it

---

🤖 Viewing Agent Decisions (MOST IMPORTANT)

👉 The actual decision-making happens in:

python inference.py

---

Example Output

[START] task=easy env=openenv_api_env
[STEP] step=1 action=retry reward=0.85 done=false
[STEP] step=2 action=accept reward=0.92 done=false
[STEP] step=3 action=accept reward=0.91 done=false
[END] success=true steps=10 score=0.92

---

🔍 What this means

• action=... → decision made by agent
• reward=... → quality of decision
• score=... → average performance

👉 This is what evaluators use.

---

🧪 Testing

Swagger UI

👉 https://rahilahmed1945-api-reliability-rl-agent.hf.space/docs

---

Testing Flow

reset → step → step → observe rewards

⚠️ In Swagger:

• YOU choose actions manually
• System only evaluates

---

🌐 Deployment

👉 Live App:

https://rahilahmed1945-api-reliability-rl-agent.hf.space

---

Ports

• External (HF): 7860
• Internal (FastAPI): 8000

---

🐳 Docker

Build

docker build -t api-agent .

Run

docker run -p 8000:8000 api-agent

---

📊 Performance

Difficulty	Score
Easy	~0.90
Medium	~0.60
Hard	~0.50

---

🧠 Key Insights

• Not just what action, but when matters
• Excess retries reduce reward
• Efficient decisions yield higher scores
• System balances reliability vs cost

---

🚀 Future Improvements

• 🤖 LLM-based decision reasoning
• 📊 Visualization dashboard
• 🧠 Deep RL (DQN, PPO)
• 🌍 Real API integrations

---

🏁 Conclusion

This project demonstrates a scalable, explainable decision intelligence system for optimizing API reliability using RL principles.

---