Models

condense's compaction models are the engines that rewrite the repeated context in a request before it reaches your provider. Two are generally available, helene-1 (the default) and adeline-1. Pick one with the model field, or let the proxy choose.

Overview

Both models are generally available and run behind the same proxy: they work with the Anthropic and OpenAI routes and with the direct /v1/compress endpoint. Compaction is metered, it draws condense credits, while the upstream model call is still billed to your own provider key.

helene-1

Helene 1 Default

The fast, accuracy-first pass for general use, the proxy's default compaction engine.

View model →

adeline-1

Adeline 1 Long traces

The heavy lifter for long agent traces, resolved in a handful of parallel passes rather than token by token.

View model →

Helene 1

Model id helene-1

Best for General use

Providers Anthropic · OpenAI

Tunable compression_rate

Metered Yes

Helene 1 is the fast, accuracy-first pass and the default compaction engine on the proxy. On a standard question-answering benchmark, a model answering from Helene 1's compacted context scored higher than the same model reading the full, untouched transcript, while sending far fewer tokens. The full numbers are in the Helene 1 announcement.

When to use. Reach for Helene 1 for general traffic and everyday sessions. It is the default, so running through the proxy with no model set already uses it.

Helene 1 accepts an optional compression_rate between 0 and 1 to trade savings against fidelity. Omit it for the auto ratio; set a fixed value (for example 0.2) to pin the target.

Compress a transcript with Helene 1

import httpx

resp = httpx.post(
    "https://api.condense.chat/v1/compress",
    headers={"X-Condense-Auth-Token": "ak_..."},
    json={
        "model": "helene-1",
        "compression_rate": 0.2,
        "messages": [{"role": "user", "content": "<a transcript to compact>"}],
    },
)
print(resp.json())

const resp = await fetch("https://api.condense.chat/v1/compress", {
  method: "POST",
  headers: {
    "X-Condense-Auth-Token": "ak_...",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "helene-1",
    compression_rate: 0.2,
    messages: [{ role: "user", content: "<a transcript to compact>" }],
  }),
});
console.log(await resp.json());

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body := []byte(`{"model":"helene-1","compression_rate":0.2,"messages":[{"role":"user","content":"<a transcript to compact>"}]}`)
    req, _ := http.NewRequest("POST", "https://api.condense.chat/v1/compress", bytes.NewReader(body))
    req.Header.Set("X-Condense-Auth-Token", "ak_...")
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = Client::new()
        .post("https://api.condense.chat/v1/compress")
        .header("X-Condense-Auth-Token", "ak_...")
        .json(&json!({
            "model": "helene-1",
            "compression_rate": 0.2,
            "messages": [{"role": "user", "content": "<a transcript to compact>"}]
        }))
        .send().await?;
    println!("{}", resp.text().await?);
    Ok(())
}

curl https://api.condense.chat/v1/compress \
  -H "X-Condense-Auth-Token: ak_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "helene-1",
    "compression_rate": 0.2,
    "messages": [
      {"role": "user", "content": "<a transcript to compact>"}
    ]
  }'

Adeline 1

Model id adeline-1

Best for Agent traces

Providers Anthropic · OpenAI

Tunable Auto

Metered Yes

Adeline 1 does the heavy lifting on long agent traces. It resolves the compacted rewrite in a handful of parallel passes instead of token by token, which is where its latency advantage comes from. The first-week-in-beta aggregates, measured on live Claude Code and SDK traffic, are in the Adeline 1 release note.

When to use. Prefer Adeline 1 for long agent traces where deep compaction matters more than the last millisecond. Set "model": "adeline-1" on the request.

Compact an agent trace with Adeline 1

import httpx

resp = httpx.post(
    "https://api.condense.chat/v1/compress",
    headers={"X-Condense-Auth-Token": "ak_..."},
    json={
        "model": "adeline-1",
        "messages": [{"role": "user", "content": "<a long agent trace to compact>"}],
    },
)
print(resp.json())

const resp = await fetch("https://api.condense.chat/v1/compress", {
  method: "POST",
  headers: {
    "X-Condense-Auth-Token": "ak_...",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "adeline-1",
    messages: [{ role: "user", content: "<a long agent trace to compact>" }],
  }),
});
console.log(await resp.json());

package main

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

func main() {
    body := []byte(`{"model":"adeline-1","messages":[{"role":"user","content":"<a long agent trace to compact>"}]}`)
    req, _ := http.NewRequest("POST", "https://api.condense.chat/v1/compress", bytes.NewReader(body))
    req.Header.Set("X-Condense-Auth-Token", "ak_...")
    req.Header.Set("Content-Type", "application/json")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    out, _ := io.ReadAll(resp.Body)
    fmt.Println(string(out))
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = Client::new()
        .post("https://api.condense.chat/v1/compress")
        .header("X-Condense-Auth-Token", "ak_...")
        .json(&json!({
            "model": "adeline-1",
            "messages": [{"role": "user", "content": "<a long agent trace to compact>"}]
        }))
        .send().await?;
    println!("{}", resp.text().await?);
    Ok(())
}

curl https://api.condense.chat/v1/compress \
  -H "X-Condense-Auth-Token: ak_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "adeline-1",
    "messages": [
      {"role": "user", "content": "<a long agent trace to compact>"}
    ]
  }'

Not sure which to send? Start with Helene 1 for general use and switch to Adeline 1 when a session is a long agent trace. Wiring and headers are in the API reference.