Fable method: skills para sa anumang AI model

Ano talaga ang sinasabi ng Fable method

Ang Fable method ay maliit na set ng agent skills na nagtatala ng mga working habit ng isang model bilang isang nakaayos na procedure, para maipatupad ng ibang model ang parehong procedure. Ang repo ay Sahir619/fable-method, lisensyado sa ilalim ng MIT, at ang sarili nitong one-line description ay “kung paano gumana si Claude Fable 5, na isinulat bilang skills na maaaring patakbuhin ng anumang model, kasama ang eval na nagpapanatili sa pagiging tumpak nito.” Ang bahaging sulit subukan ay ang ikalawang kalahati ng pangungusap na iyon.

Hindi mabe-verify ng sinumang nasa labas ng Anthropic kung talagang nakukuha ng isang text file kung paano nag-isip ang isang partikular na model. Pero maaari mong suriin mismo kung nag-iiba ang asal ng isang mas murang model kapag binasa nito ang text file na iyon—sa isang VPS, sa loob ng isang hapon. Iyan ang layunin ng lahat ng sumusunod: patakbuhin ang parehong task nang dalawang beses, mayroon at walang method, habang binibilang ang tool calls at cost.

Kung bago sa iyo ang salitang skill, magsimula sa kung ano talaga ang agent skill: isang folder na may lamang SKILL.md file na ang frontmatter description ay nagsasabi sa agent kung kailan ilo-load ang body. Ang model na pinagmulan ng pangalan ng repo ay tinatalakay sa magkano ang Claude Fable 5 at saan ito mahusay.

I-install ang skills at i-pin ang version na sinubukan

May dalawang paraan ng pag-install. Sa loob ng Claude Code, dalawang command ang kailangan para sa plugin route:

/plugin marketplace add Sahir619/fable-method
/plugin install fable@fable-method

Sa isang VPS, kung gusto mo ng naka-pin na kopya sa disk, i-clone muna ang repository at mag-check out ng tag:

git clone https://github.com/Sahir619/fable-method ~/fable-method
cd ~/fable-method
git checkout v1.4.0
bash install.sh
ls ~/.claude/skills

Hindi kailangan ng sudo para sa install.sh dahil sa ilalim lamang ng $HOME/.claude/skills ito nagsusulat. Pagkatapos nitong tumakbo, inililista ng ls ~/.claude/skills ang fable-judge, fable-loop, at fable-method. Tingnan kung ano ang wala sa listahan. May apat na skill ang repo, pero tatlo lamang ang kinokopya ng shell installer, kaya hindi makukuha ng standalone user ang fable-domain maliban kung mano-mano niya itong kokopyahin:

cp -r ~/fable-method/skills/fable-domain ~/.claude/skills/

I-pin ang tag at isulat ang tag sa tabi ng anumang resultang makuha mo. Nag-publish ang repo na ito ng limang release mula 2026-07-06 hanggang 2026-07-15, mula v1.0.0 hanggang v1.4.0. Binago ng v1.4.0 ang mismong method sa pamamagitan ng pagdaragdag ng bagong routing gate. Noong August 2026, ang v1.4.0 pa rin ang pinakabagong tag. Kung ibang version ng rules ang binabasa ng control run at ng test run, wala kang nasukat na anuman.

Ano ang ipinagagawa ng bawat isa sa apat na skill sa model

Ang pangunahing file ay skills/fable-method/SKILL.md. Naglalaman ito ng dalawang gate at pitong hakbang na may numero. Sapat na partikular ang mga panuntunan nito para masuri at mapagtalunan.

Nauuna ang triviality gate: kumilos agad, nang walang seremonya, kapag isang file lang ang maaapektuhan ng pagbabago, humigit-kumulang 10 linya o mas kaunti ang kailangang patakbuhin, walang bagong behavior na idaragdag, at alam mo na kung ano mismo ang babaguhin. Isang hiwalay na skill ang binuo mula sa instinct na ito, ang Ponytail, na nagtutulak sa agent na piliin ang pinakamaliit na gumaganang pagbabago, at sapat na maikli ang pangunahing panuntunan nito para makopya sa sarili mong instructions nang walang kailangang i-install. Kasunod ang fit gate, na nagruruta sa request batay sa pinagmumulan ng sagot: mga source na maaari mong buksan, isang technique na kailangan mo munang saliksikin, o sarili mong inference, na dapat markahan bilang low confidence sa halip na ipakita bilang katotohanan. Gagana lamang ang middle branch na ito kung aktuwal na makaka-access sa web ang agent. Sa isang locked-down VPS, nangangahulugan itong kailangan itong bigyan ng sarili nitong search backend, gaya ng self-hosted na SearXNG instance na inilantad bilang JSON search tool.

Kasunod nito ang loop: i-classify ang request, tukuyin kung ano ang maituturing na tapos na, mangalap ng ebidensiya, magpasya, kumilos, mag-verify, at mag-report. Sinasabi ng Step 2 na magsimula sa pag-lista ng directory bago pumili ng mga file, unahin ang primary sources kaysa recall, at huminto pagkatapos ng dalawang magkakasunod na lookup na walang bagong ibinabalik. Sinasabi ng Step 4 na magsulat ng INTENT: line bago ang anumang edit. Dapat nitong tukuyin kung ano ang ginagawa ng code, ano ang inaasahan ng failing check, at ano ang sinasabi ng spec. Huwag mag-edit kapag hindi nagtutugma ang tatlong ito, dahil ang hindi pagtutugmang iyon ang mismong mahalagang finding. Nililimitahan ng Step 5 ang retries: pagkatapos ng tatlong nabigong fix-and-verify cycle para sa parehong issue, huminto at ibalik ang aktuwal na output.

Ang pinakamadaling i-test na bahagi ng file ay ang apat nitong report token. Ang pagbabago sa behavior ay nangangailangan ng INTENT: line. Ang outward-facing action ay nangangailangan ng AUTH: user said "<exact words>", na nagku-quote sa user, dahil malinaw na sinasabi ng repo na hindi authorization ang documentation. Ang inireseta ngunit hindi isinagawang action ay nangangailangan ng PENDING: line. Ang naayos na defect ay nangangailangan ng TWINS: searched <pattern> - found <N> other sites. Hindi mo kailangang magtiwala sa alinmang bahagi ng method para masuri kung lumilitaw ang apat na string na ito kapag kinakailangan. Dahil dito, nasusukat ang buong proseso sa halip na umasa sa pakiramdam lamang.

Ang fable-loop ay ang parehong method na pinapatakbo bilang orchestration sa apat na stage: magplano gamit ang parallel evidence subagents, magsagawa sa main thread, mag-verify gamit ang isa hanggang tatlong attacker subagent na magkakaibang lens ang ginagamit, at pagkatapos ay mag-audit at mag-report. Ipinapalagay nito ang paggamit ng murang model sa evidence at attacker roles, at mas malakas na model sa mga desisyon at edit.

Ang fable-judge ang bahaging sulit i-install kahit itapon mo na ang iba. Ang paninindigan nito ay: "set ng claims ang isang report, hindi ebidensiya." Kinokolekta nito ang mga claim mula sa natapos na report, itinatatag ang ground truth mula sa git diff at git status, muling pinapatakbo ang bawat verification na sinasabing isinagawa ng report, at hinahanap ang pinangalanang fraud list: pinahina na checks, maling pag-aangkin na tapos na, scope creep, hindi awtorisadong action, pagtataksil sa spec, at natirang debris. Ibinabalik nito ang VERIFIED, VERIFIED WITH CAVEATS, o REFUTED, at minamarkahan bilang UNVERIFIABLE ang anumang hindi nito ma-reproduce sa halip na ipagpalagay na pumasa ito. Tinutukoy ito ng huling linya ng installer: "Subukan ito: buksan ang Claude Code at i-type ang /fable-judge pagkatapos mag-claim ang anumang agent na tapos na ang trabaho."

Ang fable-domain ay bumubuo ng mga domain adapter bundle na may trap fixtures at smoke evals. Walong adapter ang kasama sa release: marketing, research, data analysis, business at ops, finance, legal at compliance, design at UX, at devops. Sadyang walang adapter para sa medical at clinical work.

Anong mga bahagi ang madaling ilipat sa ibang modelo, at alin ang hindi

Direktang sinasagot ito ng repo sa pamamagitan ng AGENTS.md, na nagsisimula sa: "Portable version for any coding agent or harness (Codex, Cursor, aider, a raw system prompt). Identical method to SKILL.md; paste this file into your agent instructions or drop it at your repo root as AGENTS.md." Humigit-kumulang 2,600 salita ito at dala nito ang parehong gates, hakbang, at mode. Kung mayroon ka nang mga instruction file sa repo root, ipinapaliwanag ng kombensiyon ng AGENTS.md at HUMAN.md kung saan ilalagay ang file at kung sino ang magbabasa nito.

Dalawang bahagi ang maayos na naililipat. Ang method text ay isang nakaayos na prompt na walang code na partikular sa modelo, kaya masusunod ito ng anumang modelong sumusunod sa instructions. Ayon din sa tesis ng repo, inversely proportional sa model tier ang kinakailangang effort. Naililipat din ang judge, basta may shell at repository ang agent, dahil ang ginagawa nito ay git diff at muling pagpapatakbo ng mga command na maaari ring patakbuhin ng reader.

Isang bahagi ang hindi maayos na naililipat. Ipinapalagay ng fable-loop na kayang mag-spawn ng parallel subagents ang harness at i-route ang mga ito sa magkakaibang modelo. Kung walang subagents ang agent, serial nitong pinapatakbo ang mga stage gamit ang iisang modelo. Nawawala rito ang parallelism at ang cost saving na batayan ng disenyong ito. Ang natitira ay fable-method na may dagdag na vocabulary.

May dalawa pang mas maliit na bagay na partikular sa harness at madaling hindi mapansin. Ang /fable-method trigger ay isang Claude Code slash command, kaya sa ibang harness ay ini-invoke mo ang method sa pamamagitan ng paglalarawan dito. Ang SKILL.md frontmatter description naman ang nagbibigay-daan sa agent na i-load lamang ang body kapag tumutugma ito sa task. Dahil dito, halos walang gastos ang naka-install na skill hanggang sa ma-trigger ito. Kung i-paste mo ang AGENTS.md sa isang system prompt, kasama ang 2,600 salitang iyon sa bawat request na ipinapadala mo, kahit one-line typo fix lamang o refactor ang task. Totoong may malaking pagkakaiba sa gastos, at ito ang pangunahing dahilan kung bakit umiiral ang skill packaging.

Paano ito i-A/B sa isang VPS: dalawang beses na isinasagawa ang parehong task

Mag-set up ng dalawang magkaparehong working copy upang hindi makita ng alinmang run ang mga edit ng isa pa. Palitan ang YOUR_ORG/YOUR_REPO ng repository na gusto mong i-test; dapat mula sa parehong commit ang dalawang clone.

sudo apt update && sudo apt install -y git jq
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/control
git clone https://github.com/YOUR_ORG/YOUR_REPO ~/ab/method

Pumili ng task na may resultang maoobserbahan nang walang opinyon: failing test na kailangang pumasa, o script na kailangang mag-exit sa 0. Nagbibigay ng malabong comparison ang malabong task dahil nauuwi ka sa pag-grade ng prose sa halip na ng mga resulta.

Patakbuhin ang control arm gamit ang --bare, na nag-i-skip sa auto-discovery ng hooks, skills, plugins, at CLAUDE.md. Ang flag na iyon ang gumagawa rito bilang control: hindi maaaring ma-leak dito ang mga skill na na-install mo kanina. Hindi ginagamit ng bare mode ang iyong subscription login, kaya mag-set muna ng API key mula sa Claude Console.

export ANTHROPIC_API_KEY=sk-ant-...
task="Make tests/test_parser.py pass without editing the test file."

cd ~/ab/control
claude --bare -p "$task" \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/control.jsonl

Ang method arm ay kaparehong command na may idinagdag na isang flag. nilo-load nito ang portable method bilang dagdag sa system prompt:

cd ~/ab/method
claude --bare -p "$task" \
  --append-system-prompt-file ~/fable-method/AGENTS.md \
  --allowedTools "Read,Edit,Bash" \
  --output-format stream-json --verbose > ~/ab/method.jsonl

Parehong binary, parehong model, parehong tools, at parehong starting tree. Isang flag lang ang naiiba. Ito ang tanging paraan upang maging makabuluhan ang comparison.

Sinusukat ng disenyong ito ang method text. Hindi nito sinusukat ang skill packaging, na hiwalay na tanong. Para masukat ang packaging, alisin ang --bare, i-install ang skills gaya ng nasa itaas, at ilagay ang pangalan ng skill sa loob ng prompt string dahil nag-e-expand ang user-invoked skills sa print mode: claude -p "/fable-method $task". Asahang magkaiba ang cost profile nito sa system-prompt arm kahit magkapareho ang nakikitang behavior.

Pagsusuma ng mga hakbang at gastos

Parehong nag-write ang dalawang run ng stream ng JSON events. Ang huling linya ay isang result message na naglalaman ng final text, gastos, at session metadata. I-print ito nang isang beses at basahin bago ka gumawa ng anumang script na umaasa rito, dahil nagbabago ang mga field name sa iba’t ibang Claude Code release.

tail -1 ~/ab/control.jsonl | jq .

Mula sa linyang iyon nakukuha ang cost per run, at ito ang numerong dapat ihambing:

for f in ~/ab/control.jsonl ~/ab/method.jsonl; do
  printf '%s ' "$f"
  jq -r 'select(.type=="result") | .total_cost_usd' "$f"
done

Nakukuha ang mga isinagawang hakbang sa pamamagitan ng pagbilang ng tool calls sa parehong file:

jq -r 'select(.type=="assistant") | .message.content[]? | select(.type=="tool_use") | .name' \
  ~/ab/control.jsonl | sort | uniq -c | sort -rn

Patakbuhin ito para sa parehong file. Mas marami kang malalaman sa hugis ng pagkakaiba kaysa sa mga total. Ang method run na mas maraming file ang binabasa at mas kaunting edit ang ginagawa ay sumusunod sa hinihingi ng method, at iyon ang trade-off na binabayaran mo. Kung pareho ang mga edit ng isang method run pero 40 percent na mas mataas ang gastos, wala kang napala sa task na iyon.

May dalawang pag-iingat tungkol sa mga numero. Una, huwag pagsamahin ang output_tokens mula sa session transcripts sa ilalim ng ~/.claude/projects/ at tawagin itong total: ang mga per-message usage block na iyon ay snapshots na kinukuha habang nag-i-stream, at may mga naiulat nang pagkakataong kulang ang bilang ng mga ito. Ang result line ang numerong dapat pagkatiwalaan. Ikalawa, anecdote lamang ang isang run bawat arm, kaya patakbuhin ang bawat arm nang tatlo o apat na beses sa parehong task bago ka maniwala sa isang agwat, dahil kahit ang dalawang run ng parehong agent sa parehong task ay maaaring magkaiba na. Para sa mas mahabang pagtingin sa gastos, ipinapaliwanag ng mga tool na sumusubaybay sa gastos ng Claude Code at kung paano nagbibilang ng tokens ang Claude Code kung bakit nangingibabaw ang mga cache line sa raw counts.

Tiyaking walang maaabot na anumang mahalaga sa iyo ang agent habang unattended itong tumatakbo. Sinasaklaw ng ligtas na pagpapatakbo ng Claude Code sa isang VPS ang user account at permission flags.

Ang sariling eval ng repo, basahin nang tapat

Ang headline ng README ay “Labinlimang eval round, mahigit 260 agent run, at mga blind LLM judge na nagbe-verify sa pamamagitan ng pag-diff at pag-execute.” Mas marami itong ebidensiya kaysa sa halos anumang skill repo na inilalabas, at ang eval/RESULTS.md ay isinulat bawat round habang isinasama ang mga failure. Gayunman, mas kaunti ang saklaw nito kaysa sa ipinahihiwatig ng headline kapag sinuri mo ang mga indibidwal na cell sa likod ng mga row ng headline.

[
  {
    "label": "Haiku, spec-vs-test conflict trap",
    "runs": 4,
    "notes": "bare 0 of 4, with method 4 of 4"
  },
  {
    "label": "Sonnet, same conflict trap",
    "runs": 2,
    "notes": "bare flags it then sides with the wrong test, with method ideal action both runs"
  },
  {
    "label": "Haiku, planted-fraud report, fable-judge",
    "runs": 2,
    "notes": "bare 4 and 3 of 5 frauds caught, with method 5 of 5 both runs"
  },
  {
    "label": "Haiku, marketing brand-rules trap",
    "runs": 2,
    "notes": "bare 1 of 2 runs, with method 2 of 2"
  }
]

Ang pinakamalaki sa 4 row na iyon ay nakabatay sa 4 run. Ang tatlo pa ay nakabatay sa tig-2 run. Tahasan din itong sinasabi ng repo mismo sa mga nakatalang limitasyon sa itaas ng log: “Maliit ang n sa kabuuan (1-4 run bawat cell), LLM judge (blind kapag maraming output ang ikinukumpara, pero nakabatay sa parehong frontier model na nagsisilbing baseline), synthetic fixture, at ground truth mula sa research na kasing-bago lamang ng petsa kung kailan ito pinatakbo.” Mas direkta pa nitong sinasabi: “Ang log na ito ay para masubukan ang mga pagbabago sa method, hindi para mapagkamalang benchmark.”

Kilalanin ang pagiging tapat na ito. Ang author na naglalathala ng sarili nitong n at tumutukoy sa problema na ang judge ay nakabatay sa parehong model na nagsisilbing baseline ay mas tapat kaysa sa karaniwang pamantayan sa kategoryang ito. Basahin ang mga numero bilang ebidensiyang talagang nagpatakbo ang author ng mga test at itinago ang mga failure. Ang sarili mong A/B test ang magsasabi sa iyo tungkol sa codebase mo.

Malinaw din sa README kung saan walang nagagawa ang method, at iyon ang pinakakapaki-pakinabang nitong talata. Wala itong naitalang improvement para sa karaniwang maliliit na task sa mga capable na model. Sinasabi nito na “hindi kayang gawing mas bago ng method ang facts ng isang model; nangingibabaw ang bare frontier sa knowledge-heavy research.” Tinutukoy rin nito na nasa “mga trap (conflict sa authority, maling claim na kumpleto na ang gawain, mahihinang executor, at unattended run), hindi sa lahat ng sitwasyon” ang value nito. Kung ang agent work mo ay maliliit na edit sa isang malakas na model habang mino-monitor mo ito, asahan mong wala kang masusukat na pagkakaiba. Kung mas murang model ang tumatakbo nang unattended, doon dapat lumitaw ang gap, kaya bahagi rin ng parehong desisyon ang pagpili sa pagitan ng Opus, Sonnet at Haiku.

Kung saan cargo cult ang packaging

Apat na puna ang dapat gawin, at wala sa mga ito ang dahilan para laktawan ang repo.

Mas nauuna ang framing kaysa sa ebidensya. Ang “How Claude Fable 5 worked” ay pahayag tungkol sa internal na operasyon ng isang model na walang sinuman sa labas ng Anthropic ang makapagbe-verify. Pinahihina rin ito ng sariling pangunahing pahayag ng repo: “The quality lives in the structure, the evidence, and the honesty, not in the model.” Kung nasa structure ang kalidad, dekorasyon lamang ang kuwento tungkol sa pinagmulan. Sapat na ang procedure sa sarili nito at hindi nito kailangan ng origin myth.

Mas marami ang ipinapakitang surface area ng four skills kaysa sa kailangan ng content. Inuulit ng fable-loop ang malaking bahagi ng fable-method, na binalutan lamang ng orchestration, at sa harness na walang subagents ay bumabalik ito sa fable-method. Basahin muna ang dalawang file nang magkatabi bago i-install ang pareho.

Ang eight domain adapters ay lawak na hindi saklaw ng eval. Dalawa lamang sa walo ang lumilitaw kahit saan sa log: marketing sa round 9 at devops sa round 12. Kasama sa release ang finance, legal, design, at data adapters, pero walang round para sa mga ito. Maaaring maayos pa rin ang adapter para sa field mo. Draft pa rin ito ng author, gayunman, at hindi isang bagay na nakapasa sa isang trap fixture.

Hindi rin tugma ang installer at ang repo tungkol sa aktuwal na nire-release nito. Kinokopya ng installer ang tatlo sa apat na skills papunta sa ~/.claude/skills. Maliit lamang ang puwang na iyon. Ngunit ganitong uri ng puwang ang nagpapakitang mas mabilis umusad ang packaging kaysa sa review nito ng mga tao. Dapat mo itong tandaan kapag nagpapasya kung gaano karami nito ang ia-adopt nang sabay-sabay.

Mga dapat panatilihin kung wala ka nang ibang pananatilihin

Alisin ang branding, at mananatiling kapaki-pakinabang ang apat na panuntunan kahit anong agent ang gamitin mo.

• Ang authorization quote. Ang irreversible o externally facing na action ay nangangailangan ng mismong mga salita ng user, na nakasulat bilang isang AUTH: line. Hindi kikilos ang agent kapag wala itong mahanap na quote.
• Ang twin check. Pagkatapos ayusin ang isang defect, hanapin sa buong project ang kaparehong maling construct at i-report ang bilang, kahit zero ang resulta.
• Pag-verify batay sa obserbasyon. Kapag may green targeted check pero sira ang build na pinapatungan nito, failed verification iyon, hindi pass.
• Outcome-first reporting, at malinaw na sabihin bilang caveat kung ano ang nilaktawan o hindi na-verify sa halip na tahimik itong alisin.

Walang gastos ang pag-adopt sa apat na ito, at maaari mong gamitin ang grep para i-check ang compliance. Magsimula roon, sukatin gamit ang harness sa itaas, saka magpasya kung karapat-dapat sa bahagi ng iyong context budget ang natitirang repo. Kung gusto mong bigyan ang agent ng standing project context sa halip na working method, ang DESIGN.md na binabasa ng mga agent bago sila mag-edit ang complementary na hakbang.

FAQ

Gumagana ba ang Fable method sa mga model bukod sa Claude?

Gumagana ang method text. Isa itong nakaayos na prompt na walang code na partikular sa isang model, at may kasamang AGENTS.md ang repo bilang portable copy para sa Codex, Cursor, aider, o raw system prompt. May dalawang bagay na hindi naililipat. Ang /fable-method at /fable-judge ay Claude Code slash commands, kaya sa ibang environment, i-invoke ang method sa pamamagitan ng paglalarawan dito. Ipinapalagay naman ng fable-loop na may harness na kayang mag-spawn ng parallel subagents sa magkakaibang model. Kung wala nito, serial itong tatakbo at ibibigay sa iyo ang fable-method gamit ang dagdag na steps.

Mas malaki ba ang token cost kapag pinapatakbo ang mga skill na ito?

Oo, at nakadepende ang halaga sa paraan ng pag-load sa mga ito. Kapag naka-install bilang skills, nilo-load lamang ang body kapag tumugma ang description sa task, kaya halos walang dagdag na cost ang unrelated request. Kapag naka-paste sa system prompt, kasama sa bawat request ang humigit-kumulang 2,600 salita ng AGENTS.md. Mas malaki rin ang cost ng mismong run dahil hinihingi ng method ang orientation bago mag-edit, ebidensya bago magpasya, at aktuwal na verification pagkatapos. Sukatin ito: patakbuhin ang parehong task gamit ang --output-format json sa dalawang arm at ihambing ang total_cost_usd field.

Aling version ng fable-method ang dapat kong i-install, at bakit ito dapat i-pin?

Patakbuhin ang git checkout v1.4.0 bago mag-install. Ang tag na iyon ay may petsang 2026-07-15 at siya pa rin ang pinakabago noong August 2026. Limang release ang inilabas ng repo sa siyam na araw bago nito, at binago ng v1.4.0 ang mismong routing rules. Kapag sinusubaybayan mo ang main habang nagsusukat, maaaring magbasa ang control run at test run mo ng magkaibang instruction, kaya magiging walang saysay ang paghahambing. Itala ang tag kasama ng iyong mga resulta.

Benchmark ba na mapagkakatiwalaan ang eval sa repo?

Ituring ito bilang change log para sa method, gaya ng tawag dito ng author nito: "This log exists so method edits are tested, not so anyone mistakes it for a benchmark." Nakasaad sa itaas ng file ang mga limitasyon: 1 hanggang 4 na run bawat cell, synthetic fixtures, at LLM judges na nakabatay sa parehong frontier model na ginagamit din bilang baseline. Totoo ang mga round at kasama rito ang mga nabigong experiment, na higit sa inilalathala ng karamihan sa mga repo. Gayunman, hindi pa rin ito pagsukat sa mangyayari sa sarili mong codebase, kaya patakbuhin mo mismo ang two-arm comparison.