# Lite-Harness SDK

> Source: <https://dev.to/jeancarlosn/lite-harness-sdk-3f28>
> Published: 2026-06-25 12:37:20+00:00

AI harnesses are the new vendor lock-in. To swap across harnesses easily without rewriting your app, LiteLLM launched the **Lite-Harness SDK**.

Run your prompt across different harnesses:

``` python
from lite_harness import query, AgentOptions

prompt = "Fix the failing test"

# Claude Code harness
async for message in query(
    prompt=prompt,
    options=AgentOptions(harness="claude-code", model="claude-opus-4-8"),
):
    print(message)

# Codex harness
async for message in query(
    prompt=prompt,
    options=AgentOptions(harness="codex", model="gpt-5.5"),
):
    print(message)
```

To enable cost controls, fallbacks, and logging, point it to your LiteLLM AI Gateway:

```
export LITELLM_API_BASE=https://litellm.your-company.com/v1
export LITELLM_API_KEY=sk-litellm-...
```

**Engineer's Takeaway:**

This SDK unifies how you *invoke* the agents, not how they run internally. Each harness keeps its native loop and tool-calling semantics. It is perfect for A/B testing agent performance and centralizing costs, but remember it is in public beta, so custom tool injection might require extra work!

My team was building an internal bot to fix failing CI/CD tests. We had three engineers advocating for three different harnesses: one wanted Claude Code, another Codex, and another Pi AI. Without an abstraction layer, we would have had to maintain **three forks of the same bot**, with three different SDKs, three logging systems, and three ways to track costs. It would have been an impossible maintenance burden.

The SDK solved that exact pain point in **three concrete dimensions**:

Instead of maintaining three separate implementations, I had **a single query()** that routed to whichever harness I wanted. Switching from Claude Code to Codex was literally just changing a string in the options. This allowed us to do real A/B testing in production for two weeks without rewriting any core logic.

By connecting it to the LiteLLM AI Gateway, I could suddenly see on a single dashboard:

Without the gateway, tracking the real cost of an agent (which makes multiple sequential tool calls) is a nightmare of scattered logs.

When Anthropic released new capabilities in Claude Opus 4.8, I just updated the model string. I didn't have to touch the bot's underlying code. That's the real promise of LiteLLM: **decoupling your application from the provider**.

`max_iterations`

, an agent can burn $5 in tokens if it gets stuck in an infinite loop. I had to wrap the `query()`

call in an `asyncio.wait_for`

with a strict timeout to protect our budget.**Lite-Harness probably saved me 3 weeks of integration work** and gave me hard data to make an informed architecture decision. We ended up choosing Claude Code as our primary harness and Codex as a fallback for simpler, cost-sensitive tasks.