Configuration Parsing Warning:In adapter_config.json: "peft.task_type" must be a string

CaptchaKraken TwilightV2-2B-LoRA (LoRA adapter + heads)

The unmerged training output of CaptchaKraken/TwilightV2-2B: the rank-16 LoRA adapter for Qwen/Qwen3.5-2B and the pointer heads. Most people want the merged CaptchaKraken/TwilightV2-2B (ready for vLLM) or CaptchaKraken/TwilightV2-2B-GGUF (CPU, llama.cpp). This repo is for continuing training or merging onto a different base build.

The Twilight V2 family (2B)

Twilight V2 is the 2B CaptchaKraken v2 pointer model. Every repo below holds the same trained model:

Repo What
CaptchaKraken/TwilightV2-2B merged bf16 weights, for vLLM (GPU)
CaptchaKraken/TwilightV2-2B-q4 4-bit GPTQ (W4A16) weights, for vLLM (GPU) β€” not published yet
CaptchaKraken/TwilightV2-2B-LoRA unmerged LoRA adapter + pointer heads, for further training β€” this repo
CaptchaKraken/TwilightV2-2B-GGUF llama.cpp builds (Q4_K_M, BF16, mmproj), for CPU

The other v2 pointer families: Sunlight V2 (0.8B, CaptchaKraken/SunlightV2-0.8B), Midnight V2 (4B, CaptchaKraken/MidnightV2-4B).

What this is

The generation-3 pointer model: Qwen/Qwen3.5-2B with LoRA (rank 16, alpha 32, on the language model's attention, linear-attention and MLP projections and the vision tower's qkv/proj/linear_fc*) and small heads that read the whole answer (action, points, drags, text, video moment) from one prefill of the prompt. There is no text generation.

  • Training run 20261102-qwen-2b-44k: 43,963 boards (about 1.9 passes over 23,343 rows), lr 1e-4 (heads 1e-3), accum 8, gradient checkpointing, half the boards drawn with numbered element marks. Trained on one RTX 5080 (0.65 s/board, 10.8 GiB peak). CaptchaKraken/TwilightV2-2B was exported from this run.
  • Prompt: the fixed single prompt ("every captcha is asked the same prompt").

Files

  • adapter_model.safetensors, adapter_config.json: the PEFT adapter. base_model_name_or_path is set to Qwen/Qwen3.5-2B (training used a local snapshot of it, revision 15852e8).
  • pointer_heads.safetensors: the heads, keys pointer_heads.<name>, float32. Identical to the run's heads.pt["heads"] and to the file in CaptchaKraken/TwilightV2-2B.
  • training_config.json: the training run's own config.json (renamed so loaders don't mistake it for a model config).
  • client-fixes.patch: the same patch as in CaptchaKraken/TwilightV2-2B; see below.

To rebuild the merged model, merge the adapter onto Qwen/Qwen3.5-2B (PeftModel.from_pretrained(...).merge_and_unload()), save it, copy pointer_heads.safetensors beside it, and add the pointer block and the CaptchaPointerForConditionalGeneration architecture to config.json exactly as CaptchaKraken/TwilightV2-2B's config.json has them.

Loading it (read this first)

The heads match client commit ef2ec28 of CaptchaKraken plus client-fixes.patch (in this repo; it changes python/src/captchakraken/pointer/, including the SunlightV2-0.8B card's two serving fixes). The unpatched ef2ec28 client will refuse these heads (PACKED = 225). Tested with vLLM 0.25.1.

End-to-end solve rate (Tier 3)

Tier 3 is the whole product working: the CaptchaKraken client opens a real browser, finds the captcha on the page, asks this model, then clicks, drags, types or holds like a person, and the page's own answer check decides whether it was solved. It covers 149 captcha kinds from 18 vendors, each rebuilt as a local page from real captures, driven through both the Python and the JavaScript client (298 kind Γ— client pairs). A pair counts as solved when 2 attempts succeed, out of at most 3, each on a freshly dealt board. Mobile repeats 14 kinds on an emulated Pixel 7 with touch input. The gauntlet deals boards that cannot be solved mixed with ones that can, and passes only if the client works through the impossible ones without stalling and solves the rest.

Pairs solved Sunlight Twilight Midnight Abyss (hosted API)
All kinds 73% (219/298) 79% (236/298) 84% (251/298) 88% (263/298)
Mobile (Pixel 7) 54% (15/28) 86% (24/28) 79% (22/28) 86% (24/28)
Gauntlet 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)

By vendor (pairs; each kind counts twice, once per client):

Vendor Sunlight Twilight Midnight Abyss (hosted API)
hCaptcha 81% (158/194) 86% (166/194) 92% (178/194) 93% (180/194)
Dingxiang 60% (12/20) 70% (14/20) 70% (14/20) 85% (17/20)
GeeTest 62% (10/16) 75% (12/16) 75% (12/16) 88% (14/16)
FunCaptcha (Arkose) 14% (2/14) 14% (2/14) 14% (2/14) 36% (5/14)
NetEase Yidun 29% (4/14) 57% (8/14) 64% (9/14) 79% (11/14)
reCAPTCHA 50% (4/8) 75% (6/8) 75% (6/8) 75% (6/8)
BotDetect 100% (6/6) 100% (6/6) 100% (6/6) 100% (6/6)
Tencent 100% (6/6) 100% (6/6) 100% (6/6) 100% (6/6)
AWS WAF 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
CaptchaFox 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
HUMAN Security 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
KCAPTCHA 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
Lemin 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
MTCaptcha 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
Press-and-hold bars 100% (2/2) 0% (0/2) 100% (2/2) 100% (2/2)
Prosopo 50% (1/2) 100% (2/2) 100% (2/2) 100% (2/2)
Proton 100% (2/2) 100% (2/2) 100% (2/2) 100% (2/2)
Yandex SmartCaptcha 0% (0/2) 0% (0/2) 0% (0/2) 0% (0/2)

By what the captcha asks for:

Kind Sunlight Twilight Midnight Abyss (hosted API)
Click a still board 66% (101/154) 81% (125/154) 81% (125/154) 88% (136/154)
Click an animated board 79% (22/28) 68% (19/28) 86% (24/28) 79% (22/28)
Drag 83% (68/82) 80% (66/82) 90% (74/82) 93% (76/82)
Slider 75% (12/16) 75% (12/16) 75% (12/16) 81% (13/16)
Type the text 83% (10/12) 83% (10/12) 83% (10/12) 83% (10/12)
Press and hold 100% (6/6) 67% (4/6) 100% (6/6) 100% (6/6)

Measured with the client that became release 4.2.0: Twilight, Midnight and Abyss on 2026-11-12, Sunlight on 2026-11-13 in bf16 through vLLM 0.25.1 on an RTX 3060. Twilight was served in bf16 through transformers, Midnight and Abyss as 4-bit GPTQ through vLLM 0.25.1 (Abyss's is the build the hosted API runs). Abyss is the hosted model (CaptchaKraken v1.2 Abyss), whose weights are not public. With 2–3 attempts per kind, a single kind can flip between runs, so read small vendors as rough. Known weak spots for every model: FunCaptcha's matching games, and Yandex, whose two words are bent around a curve (the larger models read the first word and lose the second).

Static image annotation solving (Tier 2)

Static image annotation solving is scored against real human solves. Every board is a real captcha captured from a vendor's live widget and solved by hand, and the points, drag ends, grid cells and text that person chose are the answer key. Each answer is scored by how close it lands to the human solve points: a click counts when every target is pressed once, each within 6% of the image diagonal of the human's point; a drag when it is dropped within 5%; a grid when it picks the same cells; typed text when it matches; and on an animated board the moment must be right too. No browser or vendor is involved: this measures how well the model reads one board, not the end-to-end solve (see Tier 3 above).

See CaptchaKraken/TwilightV2-2B (Tier 2 gate set, 1,067 hand-labelled real boards, served through vLLM 0.25.1): 72.6%. Per-board results and the run's validation split are in that repo under eval/.

Static image annotation solving across the family (Tier 2)

This adapter is the same trained model as the bf16 Twilight column. Bold marks it.

Every v2 pointer model, on the same 1,067 hand-labelled real boards (scored against the human solve points as above), served through vLLM 0.25.1. Percent of boards solved; higher is better. q4 is 4-bit GPTQ (W4A16); the others are bf16 unless named. Sunlight is the 0.8B model, Twilight 2B, Midnight 4B, Abyss 4B (the hosted API, 4-bit).

Sunlight Sunlight q4 Twilight Midnight Midnight q4 Abyss (hosted API)
All (1,067) 58.9% 59.1% 72.6% 75.4% 75.1% 78.6%
Click (674) 65.4 66.3 76.3 78.3 77.9 84.1
Grid (223) 41.7 39.9 75.8 78.9 78.9 78.9
Video (158) 57.0 57.6 54.4 59.5 59.5 57.6
Type (12) 33.3 33.3 50.0 50.0 50.0 41.7
  • Twilight solves 14 points more than Sunlight on the plain boards (clicks +11, grids +34). Midnight adds 3 more.
  • Video barely follows size: Midnight leads it at 59.5%, and the three are within 5 points of each other.
  • 4-bit moves the plain totals by 0.3 points or less. A Twilight q4 has not been measured or published.

How far to trust the gaps:

  • Twilight and Midnight were trained on the same data (23,343 rows), so their gap is model size. Sunlight (40,000 rows, 2026-11-13) and Abyss were trained on newer builds that add FunCaptcha's pager games, so their gaps are not size alone.
  • Type has only 12 boards, so treat that row as rough.
  • Sunlight and Abyss were scored on an RTX 3060, the others on an RTX 5080. The answers are compared, not the speed.
  • Abyss is the model the hosted CaptchaKraken API answers with (CaptchaKraken v1.2 Abyss): a Midnight-sized 4B trained further, served as 4-bit GPTQ. Its weights are not public, so it has no per-board link below.
  • MidnightV2-4B's own Tier 2 results were run through transformers, so use this table, not those, to compare it with the other models.

Per-board results: Sunlight, Sunlight q4, Twilight, Midnight, Midnight q4.

License: LGPL-3.0.

Downloads last month
31
Inference Providers NEW
This model isn't deployed by any Inference Provider. πŸ™‹ Ask for provider support

Model tree for CaptchaKraken/TwilightV2-2B-LoRA

Finetuned
Qwen/Qwen3.5-2B
Adapter
(411)
this model

Collection including CaptchaKraken/TwilightV2-2B-LoRA