SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor

Paritok: Mas Murang Coding Agent Bills?

Pinapaliit ng Paritok ang file reads at tool output sa bawat request. Sinasabing 74% mas kaunting tokens, pero alamin ang mekanismo at break-even math.

Ang ginagawa ng Paritok sa isang request

Ang Paritok ay isang token gateway: isang proxy na nasa pagitan ng coding agent mo at ng model API, at nagko-compress ng bawat request bago ito ipasa. Kumokonekta ang agent mo sa http://127.0.0.1:8080 sa halip na direkta sa provider. Pinapaliit ng proxy ang tool schemas, file reads, tool output, at mga naunang turn, ipinapadala ang mas maliit na payload sa upstream, at ibinabalik ang reply nang walang pagbabago.

Sinisingil ka ng provider batay sa dumarating dito, pero nakadepende ang invoice sa kung aling mga token ang inalis, sa cache pricing ng mga ito, at sa dami ng turn na kinukuha ng agent. Iyan ang buong ideya. Iba ito sa pahayag na “mas tumatagal ang iyong context,” at ito ang dahilan kung bakit kawili-wili ang tool na ito sa halip na isa lamang itong paraan para maging mas maayos ang output.

Bago pa ang project. Ginawang open source ang gateway noong 15 July 2026, at itinatala ng PyPI ang v1.3.14 bilang may petsang 6 October 2026 at ang v1.3.0 bilang may petsang 5 August. Ang weights at gateway code ay nasa ilalim ng Apache 2.0. Ang compression model ay isang LoRA (low-rank adaptation) adapter sa Qwen3-4B-Instruct-2507, na distilled mula sa pool na may 45,000 segment na kinuha sa mga aktuwal na coding-agent trajectory. Sa mga ito, 40,606 ang pumasa sa teacher validation at naging mga training example.

Bakit hindi ito context trimming

Binubura nang tuluyan ng trimming ang content. Kapag malapit na ang agent sa limit ng context nito at inaalis nito ang pinakamatatandang turn, wala na ang file na binasa nito sa turn 3. Kung kailangan nito ang file sa turn 20, babasahin nitong muli ang file, kaya magbabayad ka ulit para sa mga token na iyon. Pansamantala lamang ang natipid.

Pinapalitan ng Paritok ang isang segment ng mas maikling anyo at tag, [REF:id], habang pinananatili ang buong text sa proxy. Binabawi ng model ang isang segment sa pamamagitan ng pagtawag sa read_original o expand_context. Binabago nito ang paraan ng paglitaw ng failure. Ang trimmer ay nagfa-fail dahil nakakalimot ito, at hindi nito ipinapaalam sa iyo. Ang compressor naman ay nagfa-fail dahil nagbibigay ito sa model ng excerpt na may nawawalang detalye, at maaaring hingin ng model ang orihinal kapag hindi sapat ang excerpt.

Nananatiling nare-recover ang mga na-filter na tool schema, pero inaalis ng default adaptive filter ang mga hindi napiling standard tool at mga hindi napiling MCP tool maliban kung nag-trigger ang MCP relevance signal nito. Kapag nag-trigger ang signal na iyon, ginagawang stub ang mga hindi napiling MCP tool. Sinusuportahan ng gateway_search_tools ang recovery, at nade-detect din ng gateway ang mga mensaheng nagsasabing may nawawalang tool at nag-iinject ito ng mga katugmang tool bago muling subukan. Mahalaga ito dahil binabago ng filter na permanenteng nagtatago ng tool ang mga kayang gawin ng agent, at malalaman mo lamang ito sa pamamagitan ng task na tahimik na hindi nagtagumpay.

Ang tatlong lever at kung alin ang libre

Ang unang lever ay ang tool-schema filter. Kasama sa bawat request ang buong tools array. Sa isang Claude Code turn na walang naka-attach na MCP (model context protocol) server, tinatayang 29,000 tokens ang block na ito ng project; kapag may naka-attach na MCP, 44,000 hanggang 65,000 tokens naman. Ini-embed ng filter ang request ng user at bawat tool description gamit ang BAAI/bge-small-en-v1.5, isang 130 MB embedding model. Pinapanatili nito ang mga tool na tumutugma, inaalis ang mga hindi napiling standard tool, at gumagawa lamang ng stub para sa mga hindi napiling MCP tool kapag nag-trigger ang MCP relevance signal nito. Kung hindi, inaalis din nito ang mga MCP tool na iyon. Sa 29,000-token na halimbawa ng project, bumababa ang block sa tinatayang 8,000 tokens. Sa CPU tumatakbo ang embedding model na ito.

Ang ikalawang lever ay content compression. Ito ang bahagi na gumagamit ng 4B model, sa GPU o sa pamamagitan ng Ollama sa CPU. Binabawasan ang file reads, tool output, at history sa 25.7% ng orihinal na laki ng mga ito. Pangunahing pumipili ang model ng mga span sa halip na muling isulat ang mga ito. Limitado lamang ang rewriting para sa content gaya ng reasoning summaries at tool-call framing. Sinukat ng paper ng project na 96.0% ng mga identifier, path, at number na inilabas sa teacher-generated training corpus ay eksaktong lumalabas sa input. Sa held-out SWE-bench Lite output ng trained model, 96.2% ang score sa parehong audit. Dito nagmumula ang 74% na headline. Basahin ito nang mabuti: ang 74% ay compression rate ng content na kino-compress, hindi ang bawas sa bill mo.

Ang ikatlong lever ay history summarization. Bilang default, kapag lumampas ang context sa 80% ng naka-configure na window, sini-summarize ang mas lumang turns habang nananatiling buo ang apat na pinakabagong turns. Sa ganitong paraan, nagpapatuloy ang mahabang session sa halip na umabot sa limit.

Opsyonal ang GPU para sa self-hosting. Ito ang pinakamahalagang pangungusap sa page na ito. Ibinibigay sa iyo ng pip install "paritok[toolselect]" ang tool filter sa ordinaryong CPU VPS, nang walang per-token fee. Subukan muna ito bago mag-rent ng card.

Ano ang sinukat ng proyekto, at kaninong harness ito sinukat

TsartSWE-bench Lite: compression rate against solve quality retained (project's published figures)
Ang datos sa likod ng tsart na ito
[
  {
    "label": "Paritok-4B-v1",
    "compressed_to_pct": 25.7,
    "quality_retained_pct": 86.5
  },
  {
    "label": "gpt-4.1-mini",
    "compressed_to_pct": 50.2,
    "quality_retained_pct": 85.6
  },
  {
    "label": "gpt-5",
    "compressed_to_pct": 61.9,
    "quality_retained_pct": 93.6
  }
]

Ito ang sariling inilathalang mga figure ng proyekto, na sinukat gamit ang sarili nitong harness laban sa SWE-bench Lite. Kino-compress ng Paritok-4B-v1 ang content sa 25.7% ng orihinal na laki habang napapanatili ang 86.5% ng solve rate na hindi naka-compress. Kapag gpt-5 ang ginamit bilang compressor, mas maraming quality ang napapanatili, 93.6%, pero kino-compress lamang ito sa 61.9%; ibig sabihin, magbabayad ka ng frontier prices para makatipid ng frontier prices.

Basahin nang tama ang quality column. Ang quality retained ay solve rate ng compressor na hinati sa solve rate ng baseline na hindi naka-compress. Ang 86.5% na retained ay nangangahulugan ng 13.5% net reduction sa mga solve kumpara sa baseline; hindi nito binibilang ang porsiyento ng mga problemang nasolve sa baseline ngunit hindi nasolve dito, dahil maaari ring ibang mga problema ang masolve ng compressed runs. Sinusukat ng figure ang single-shot comprehension ng compressed raw source kapag naka-disable ang recall at naka-enable ang production edit recovery; hindi nito sinusukat ang CPU tool-schema filter o ang buong multi-turn gateway.

TsartReported input-token saving as a session grows (project's own harness)
Ang datos sa likod ng tsart na ito
[
  {
    "label": "Turn 1",
    "saved_pct": 25
  },
  {
    "label": "Turn 5",
    "saved_pct": 39
  },
  {
    "label": "Turn 12",
    "saved_pct": 57
  },
  {
    "label": "Turn 20",
    "saved_pct": 63
  }
]

Lumalaki ang end-to-end saving habang tumatagal ang session, dahil naiipon ang history at ang history ang kino-compress. Iniuulat ng proyekto ang humigit-kumulang 25% sa isang turn, 39% pagsapit ng turn 5, at 63% pagsapit ng turn 20. Turns 1 hanggang 5 lamang ang sinukat; tinatawag ng README na projections ang mga susunod na row. Tinutukoy rin nito kung saan humihinto ang paglaki: sa 200,000-token budget, nagfa-flatten ang per-turn content saving sa humigit-kumulang 48,000 tokens, bandang turn 8 hanggang 12, dahil kapag puno na ang context, hindi na lumalaki ang history. Ang hiwalay na tool-filter saving ay nagdaragdag ng humigit-kumulang 21,000 tokens bawat turn, kaya ang projected combined plateau ay humigit-kumulang 69,000 tokens bawat turn. Ang madalas na binabanggit na "past 85%" na figure ay tumutukoy sa context-saturated sessions. Ito ang pinakamagandang sitwasyon, at sinasabi rin ng README na nagpa-plateau ang saving patungo sa ceiling na humigit-kumulang 72% sa default settings, kaya huwag itong gawing batayan ng pagpaplano.

Sapat ba ang 24GB GPU para sa Paritok?

Opsyonal ang GPU, at kasya ang model sa mga card na mas maliit sa 24 GB. Para sa isang halimbawa ng rental calculation, gamitin ang $0.44 kada oras para sa 24 GB card. Kung patuloy itong tatakbo buong buwan, iyon ay 730 oras, kaya $321. Kung gagamitin lamang sa working hours, 8 oras bawat araw sa loob ng 22 araw, magiging 176 oras ito, kaya $77.

Ngayon, gawing halaga sa dolyar ang token reduction. Nalalapat ang reduction sa input tokens. Dumadaan nang hindi binabago sa proxy ang output tokens, kaya hindi nito kino-compress ang mga ito. Hiwalay na kalkulahin ang presyo ng fresh input, cache writes, at cache reads gamit ang rates ng provider mo, pagkatapos ay ikumpara ang kabuuang API cost bago at pagkatapos. Kahit 80% ng kabuuang halaga mo sa dolyar ay mula sa input, hindi sapat ang pag-multiply ng token reduction sa 0.8 para mapatunayan ang matitipid sa bill.

TsartMonthly API saving needed to cover an illustrative $0.44/hour card
Ang datos sa likod ng tsart na ito
[
  {
    "label": "Always on (730 hours)",
    "required_api_saving_usd": 321.2
  },
  {
    "label": "Workday only (176 hours)",
    "required_api_saving_usd": 77.44
  }
]

Magbabayad para sa sarili nito ang card na patuloy na tumatakbo kapag lumampas sa $321.2 ang nasukat mong buwanang matitipid sa API, o $77.44 kung ihihinto mo ang instance kapag wala nang working hours. Hindi sapat ang 85% token reduction para mapatunayan ang 68% bill saving, kaya hindi rin nito mapapatunayan ang buwanang threshold para sa agent spend. Hatiin ang rental cost sa nasukat mong bill-saving fraction para makuha ang threshold na iyon.

Dalawang bagay ang nagpapaganda sa resulta kumpara sa ipinapakita ng chart. Hindi kailangan ng model ng 24 GB: humigit-kumulang 2.5 GB ang q4 build at humigit-kumulang 8 GB ang f16 build. Kaya kung mas maliit na card ang gagamitin mo, o GPU box na pinapatakbo mo na para sa ibang gawain, bababa ang bawat halaga sa chart. At ang paghinto sa instance kapag walang nagco-code ang pinakamalaking lever dito, dahil binabawasan nito ng humigit-kumulang tatlong-kapat ang rent.

May isang bagay namang nagpapalala sa resulta. Totoong trabaho ang compression pass. Kailangang basahin ng 4B model ang bawat token na kino-compress nito, at kailangang isulat nito pabalik ang bawat span na pinananatili nito. Nagdaragdag ito ng latency sa bawat agent turn. Sa card na binabayaran kada oras, lumilitaw ang halagang ito bilang paghihintay, hindi bilang linya sa invoice, kaya madaling hindi mapansin hanggang maramdaman mo na ito.

Kung ikinukumpara mo sa pangkalahatan ang rented GPU hours sa API tokens, ginagawa ng break-even sa pagitan ng GPU VPS at API tokens ang parehong arithmetic para sa mismong inference.

Pagpapatakbo ng Paritok gateway sa isang VPS

Tumatanggap ang package metadata sa PyPI ng Python 3.10 o mas bago, kahit nakalagay sa README badge ang 3.11+. Kasama sa Ubuntu 24.04 ang Python 3.12, kaya sapat na ang plain VPS image para sa CPU tool filter.

sudo apt update && sudo apt install -y python3-venv curl
python3 -m venv /opt/paritok/venv
source /opt/paritok/venv/bin/activate
pip install "paritok[proxy]==1.3.14"
pip install "paritok[toolselect]==1.3.14"

I-lock ang bersyon. Itinatala ng PyPI ang v1.3.0 noong 5 August 2026 at ang v1.3.14 noong 6 October 2026. Kapag ganoon kabilis magbago ang isang proyekto, nagpapalit ito ng mga pangalan sa pagitan ng mga release: mismong v1.3.0 ay nagpalit ng expand_context bilang read_original sa API nito. Ang isang bare pip install paritok, o git clone ng main, ay magbibigay sa iyo ng ibang gateway sa susunod na linggo at walang itatalang bersyon kung alin ang gumawa ng mga numerong sinukat mo.

Ang default backend ay Ollama. I-pull ang model, pagkatapos ay bigyan ito ng maikling pangalan na hinahanap ng proxy.

ollama pull paritok/paritok-4b-v1
ollama cp paritok/paritok-4b-v1 paritok-4b-v1

Dahil isinusulat ng local model ang mga span na iniingatan nito para sa bawat segment na kino-compress nito, lumalabas bilang stalled agent turn ang compression pass na matagal matapos. Ang num_predict cap ng Ollama sa haba ng output ang kumokontrol sa limitasyong ito.

Isulat ang paritok.yaml sa tabi nito. Ang use_gpu_server: false ang nagpapanatili ng compression sa sarili mong hardware.

use_gpu_server: false
local_model:
  base_url: http://localhost:11434/v1
paritok proxy --port 8080 --config-file paritok.yaml

Ang paritok up ang shortcut para i-pull ang model kung wala pa ito at simulan ang proxy sa port 8080. Dapat naka-install na ang Ollama. Suriin ang proxy bago mo ito ituro sa agent.

curl http://127.0.0.1:8080/health
curl http://127.0.0.1:8080/stats

Nagbabalik ang /health ng maliit na JSON object na naglalaman ng "status":"ok" at isang version string. Nagbabalik ang /stats ng compression totals at sariling estimate ng proxy sa natipid nito. Ituring ang estimate na ito bilang pagtatasa ng proxy sa sarili nitong trabaho, at kumpirmahin ito sa usage page ng provider mo.

Para sa throughput sa halip na convenience, sine-serve ng vLLM ang adapter sa ibabaw ng base model.

vllm serve Qwen/Qwen3-4B-Instruct-2507 \
  --enable-lora \
  --lora-modules paritok-4b-v1=paritok/paritok-4b-v1 \
  --max-lora-rank 32 \
  --port 8000

Nasa sariling command ng proyekto ang flag na --max-lora-rank 32 dahil rank 32 ang adapter. Pagkatapos, itakda ang local_model.base_url sa http://localhost:8000/v1 sa paritok.yaml upang sa vLLM kumonekta ang proxy sa halip na sa Ollama.

Mas mabilis i-setup ang Ollama. Mas mahusay humawak ng concurrent requests ang vLLM, kaya nagiging mahalaga ito kapag higit sa isang agent ang gumagamit ng server. Ang praktikal na pagkakaiba ng Ollama at vLLM ang magpapasya kung alin ang gagamitin mo.

Ituro ang agent sa proxy gamit ang base URL environment variables.

export ANTHROPIC_BASE_URL=http://127.0.0.1:8080
export OPENAI_BASE_URL=http://127.0.0.1:8080

Hindi pinapansin ng Codex CLI ang OPENAI_BASE_URL, kaya isinusulat ng paritok up ang ~/.codex/config.toml para sa iyo kapag nakatakda ang codex.enabled: true sa paritok.yaml. Kapag ang variable lamang ang in-export, direktang nakikipag-usap ang Codex sa provider. Makikita ito sa /stats counter na hindi kailanman nadaragdagan habang nagtatrabaho ka.

Panatilihin ang listener sa 127.0.0.1, hindi kailanman sa 0.0.0.0. Ipinapasa ng proxy upstream ang credentials na kasama sa bawat request. Inilalantad naman ng hindi authenticated na /stats endpoint nito ang mga sample ng original at compressed content. Kaya inilalantad ng internet-facing listener ang private context at local compression resources. Ma-access ito mula sa laptop gamit ang SSH tunnel o VPN sa halip na buksan ang port.

Patakbuhin ito sa ilalim ng systemd upang manatili itong gumagana pagkatapos ng reboot. Iangkop ang mga path sa iyong install. Gawin ang paritok user na gagamitin ng unit, at bigyan ito ng install directory:

sudo useradd --system --home-dir /opt/paritok --shell /usr/sbin/nologin paritok
sudo chown -R paritok:paritok /opt/paritok
[Unit]
Description=Paritok compression proxy
After=network-online.target

[Service]
User=paritok
WorkingDirectory=/opt/paritok
ExecStart=/opt/paritok/venv/bin/paritok proxy --port 8080 --config-file /opt/paritok/paritok.yaml
Restart=on-failure

[Install]
WantedBy=multi-user.target

I-enable ito gamit ang sudo systemctl enable --now paritok, pagkatapos ay i-curl muli ang /health. Karaniwang nangangahulugan ang unit na nagsisimula at agad na lumalabas na mali ang path ng config file. Ipinapakita ng journalctl -u paritok -n 50 ang dahilan.

Ang hosted option at ang kapalit nitong gastos

Inaalok din ng project ang compression bilang isang service. I-set ang use_gpu_server: true gamit ang API key mula sa paritok.com, at tatakbo ang 4B model sa hardware nito. Simula 2 November 2026, naniningil ito ng $0.30 bawat isang milyong file token na kino-compress nito, gamit ang prepaid credit, at libre ang tool-schema filtering. Makakakuha ang mga bagong account ng $5 libreng credit nang hindi kailangan ng card. Natapos noong 1 October 2026 ang launch period kung kailan libre ang hosted service, kaya bayad na itong service ngayon. Inaalis nito ang gawain ng pagho-host ng compression model, habang ikaw pa rin ang nagpapatakbo ng gateway.

Nangangahulugan din ito na lumalabas sa iyong machine ang mga prompt mo at ang mga file na binabasa ng iyong agent, at ipinapadala ang mga ito sa isang third party bago makarating sa model provider mo. Ginagamit ang self-hosting upang maiwasan mismo ang ganitong hop. Magpasya muna kung alin sa dalawang ito ang gusto mong i-optimize bago i-set ang flag na iyon, dahil isang linya lang ang kailangang baguhin sa flag, ngunit hindi ganoon kasimple ang magiging epekto nito.

Paano sukatin ang sarili mong before at after

Ang mga numerong inilathala ay mga numero ng proyekto, mula sa harness ng proyekto, sa SWE-bench Lite. Hindi SWE-bench Lite ang repository mo. Sukatin ang sarili mong resulta.

  • Magpatakbo ng isang normal na linggo na walang proxy sa path. Itala sa magkakahiwalay na linya ang fresh input, cache-write, cache-read, at output tokens mula sa usage page ng provider mo, hindi bilang isang kabuuang halaga sa dolyar.
  • Sa susunod na linggo, patakbuhin ang proxy sa unahan at gawin ang parehong uri ng trabaho.
  • Ihambing ang mga input category batay sa aktuwal na presyo ng mga ito, at isama ang anumang pagbabago sa output cost. Hindi kino-compress ng proxy ang output, pero nakaaapekto sa dami ng output na binibili mo ang mga pagbabago sa gawi ng agent at sa bilang ng turn.
  • Bilangin ang mga task na kinailangan mong ulitin. Ito ang bahagi ng tradeoff na tungkol sa kalidad, at walang dashboard saanman ang nag-uulat nito.
  • Idagdag ang GPU hours sa week two bago ihambing ang mga total.

Mahalagang paghiwalayin ang input at output dahil magkaiba nang malaki ang presyo ng mga ito, at isa lamang sa mga ito ang naaabot ng compressor. Noong 2 November 2026, nagkakahalaga ang Claude Sonnet 4.6 ng $3 bawat milyong input tokens at $15 bawat milyong output tokens, habang ang prompt-cache read ay 10% ng input rate, o $0.30 bawat milyon. Ang mas bagong Claude Sonnet 5.5 ay nagkakahalaga ng $2 at $10, at ang cache reads nito ay 5% ng input rate, o $0.10 bawat milyon. Ang agwat sa gastos ng input at output token ang nagtatakda kung may pakinabang sa iyo ang isang input-side compressor. Ipinapakita ng Kung saan talaga napupunta ang mga token ng Claude Code kung aling bahagi ng context mo ang sapat ang laki para sulit i-compress.

Lalo na pinapahirap ng prompt caching ang arithmetic para sa tool filter. Nasa unahan ng request ang tool block, kaya pagkatapos ng unang turn ay karaniwang cache hit na ito; sa Sonnet 4.6, nagkakahalaga ito ng 10% ng input price. Ang pagbawas ng 21,000 tokens mula sa isang naka-cache na block ay nakatitipid ng 21,000 tokens sa halagang $0.30 bawat milyon, o humigit-kumulang $0.006 bawat turn, sa halip na $0.063 na ipinahihiwatig ng uncached rate. Pinananatiling hindi nagbabago ng proyekto ang filtered block sa buong session upang hindi magbago ang naka-cache na prefix. Kung muling pipili ng mga tool ang isang filter sa bawat turn, mawawalang-bisa ang prefix na iyon at maaaring mas malaki pa ang gastos kaysa sa matitipid.

Ano ang hindi pa beripikado

Ang lahat ng performance number sa itaas ay mula mismo sa project. May independent synthetic-corpus compression check, pero malinaw nitong hindi sinusukat ang task success sa SWE-bench; ang solve-quality figures ng project para sa SWE-bench Lite ay hindi pa independently confirmed. Dahil open-sourced ang gateway noong July 2026, kakaunti pa ang operational history ng code. Ang compression rate at ang quality-retained figure ay parehong sinukat ng partidong may pakinabang kapag maganda ang mga ito. Hindi ibig sabihin nito na mali ang mga ito. Ibig sabihin lamang nito na hindi pa kumpirmado ang mga ito, kaya dapat iba ang pagtingin mo sa mga ito kumpara sa numerong ikaw mismo ang gumawa.

May isang documented behaviour na dapat mong malaman bago sisihin ang setup mo. Naglo-load ang embedding model na ginagamit ng tool filter sa unang request, hindi sa startup. Kaya nagdodokumento ang project ng warm-up na 10 hanggang 15 segundo, at humigit-kumulang 15 ms bawat call pagkatapos nito. Magpadala ng isang throwaway request matapos magsimula ang proxy para hindi magmukhang nagha-hang ang unang totoong agent turn.

May apat na bagay na maaari mong alamin mismo sa loob ng isang hapon: kung nagsisimula at nananatiling tumatakbo ang proxy, kung gumagalaw ang /stats habang nagtatrabaho ka, kung talagang bumababa ang input-token line ng provider mo, at kung natatapos pa rin ng agent ang trabaho. Ang mga ito ang mas makapagsasabi kung angkop ito sa setup mo kaysa sa anumang published benchmark.

Tungkol sa puwesto nito kasama ng iba mong tooling: ang self-hosted LiteLLM gateway ay nagra-route at nagme-meter ng mga request nang hindi binabago ang nilalaman ng mga ito, kaya magkaibang problema ang nilulutas ng dalawang tool at maaari silang pagsamahin, kung saan pinakamalapit sa agent ang Paritok. Kung ang tunay na layunin ay mas maliit na bill at hindi ang partikular na tool na ito, kasama sa mas malawak na set ng cost control para sa agent sa isang VPS ang ilang pagbabagong walang gastos at maaari mong subukan muna.

FAQ

Binabawasan ba ng Paritok ang bayarin ko sa API, o ang context usage ko lang?

Pinaiikli nito ang request bago ito makarating sa provider. Nakadepende ang matitipid sa presyo ng mga token na inalis at sa bilang ng mga turn na mabubuo ng agent. Mas maliit ang aktuwal na pagbawas kaysa sa ipinahihiwatig ng headline. Ang 74% na figure ay compression rate para sa content na kino-compress. Sa end to end na pagsukat, nag-uulat ang proyekto ng humigit-kumulang 25% na matitipid sa input token sa isang turn, at tinatayang aabot ito sa 63% pagsapit ng turn 20. Hindi binabago ang output tokens, pero nakadepende pa rin sa asal ng agent ang dami ng mabubuo.

Gaano karaming GPU ang kailangan para ma-self-host ang compression model?

Opsyonal ang GPU. Pinapatakbo rin ng Ollama ang model gamit ang CPU. Humigit-kumulang 2.5 GB ang q4 build at 8 GB ang f16 build, kaya kasya ang model sa 24 GB card na marami pang natitirang espasyo. Gagana rin ang mas maliit na card, at magiging mas pabor sa iyo ang break-even calculation. Walang GPU na kailangan ang tool-schema filter. Gumagamit ito ng BAAI/bge-small-en-v1.5, isang 130 MB embedding model na tumatakbo sa CPU. I-install ang paritok[toolselect] sa karaniwang VPS upang makuha ang tool-block reduction kapalit ng kaunting RAM.

Ano ang mangyayari kung may inalis ang compressor na kailangan ng agent?

Walang permanenteng nawawala. Binubura ng model ang ilang span mula sa ipinapasa, pero may [REF:id] tag ang mga compressed segment. Binabawi ng model ang buong text gamit ang read_original o expand_context. Inaalis ng default tool filter ang mga hindi napiling standard tool at ang mga hindi napiling MCP tool, maliban kung ma-trigger ang MCP relevance signal nito. Kapag na-trigger ito, naglalagay ito ng stub para sa mga MCP tool na iyon. Gumagamit ang tool recovery ng gateway_search_tools at ng pagtukoy sa mga mensaheng nagsasabing may nawawalang tool. Mas tahimik ang tunay na panganib kaysa sa nawawalang file: gumagana ang model mula sa lossy excerpt at hindi nito namamalayang dapat nitong hingin ang orihinal. Sinusukat ng 86.5% quality-retained figure sa SWE-bench Lite ang single-shot na pag-unawa sa compressed raw source, na naka-disable ang recall at naka-enable ang production edit recovery. Hindi nito sinusukat ang CPU tool-schema filter o ang buong multi-turn gateway.

Bakit tumatagal ng 15 segundo ang una kong request?

Nilo-load ang embedding model na ginagamit ng tool filter sa unang request, hindi sa startup. Ayon sa dokumentasyon ng proyekto, tumatagal ng 10 hanggang 15 segundo ang warm-up, at humigit-kumulang 15 ms bawat call pagkatapos nito. Pagkatapos simulan ang proxy, magpadala ng isang pansamantalang request gamit ang curl. Sa ganitong paraan, hindi maaantala ang unang totoong turn ng agent.

Dapat ko bang gamitin ang hosted GPU server sa halip na mag-self-host?

Inaalis nito ang pangangailangang mag-host ng compression model at ang anumang bayad sa GPU, pero ikaw pa rin ang mamamahala sa gateway. Noong 2 November 2026, nagkakahalaga ito ng $0.30 bawat milyong file token na kino-compress. Ibinabawas ang bayad sa prepaid credit, at may $5 na libreng credit para sa mga bagong account. Natapos ang libreng launch period noong 1 October 2026. Ipinapadala rin nito ang iyong mga prompt at ang mga file na binabasa ng agent sa isang third party bago makarating ang mga ito sa iyong model provider. Kung nag-self-host ka upang mapanatili ang code sa imprastrakturang kontrolado mo, sinisira ng setting na ito ang dahilan kung bakit ka nagsimula. Sa self-hosting, nananatili ang compression sa sarili mong server. Ipinapasa pa rin upstream sa model provider ang mga compressed request at provider credential.

Nakatulong ba ang artikulong ito?