On this page
Get started
dense CLI
API reference
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.
The fast, accuracy-first pass for general use, the proxy's default compaction engine.
View modelThe heavy lifter for long agent traces, resolved in a handful of parallel passes rather than token by token.
View modelHelene 1.1
Helene 1.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.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.1 announcement.
When to use. Reach for Helene 1.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.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.
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
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.
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.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.