💬 NLP

CRANE: Constrained Reasoning Injection for Code Agents via Nullspace Editing

CRANE is een trainingsvrije parameterbewerkingsmethode die Instruct- en Thinking-code-agent checkpoints samenvoegt via nullruimte-bewerking om de prestaties op het gebied van redeneren op lange termijn en het gebruik van hulpmiddelen aanzienlijk te verbeteren, terwijl de efficiëntie behouden blijft.

Oorspronkelijke auteurs: Mingzhi Zhu, Michele Merler, Raju Pavuluri, Stacy Patterson

Gepubliceerd 2026-05-15

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Mingzhi Zhu, Michele Merler, Raju Pavuluri, Stacy Patterson

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je twee verschillende versies van een briljante software-engineer hebt, laten we ze De Commandant en De Filosoof noemen.

De Commandant (Instruct Model): Deze engineer is ongelooflijk snel, volgt strikte regels en weet precies hoe hij gereedschap (zoals een moersleutel of een compiler) moet gebruiken zonder rommel te maken. Hij haast zich echter soms om een probleem op te lossen zonder het blauwdruk volledig te begrijpen, wat leidt tot fouten.
De Filosoof (Thinking Model): Deze engineer is een meester in plannen. Hij denkt diep na, overweegt elke hoek en heeft uitstekende strategieën om zich te herstellen wanneer dingen misgaan. Maar hij is ook vatbaar voor "overdenken". Hij kan urenlang debatteren over de beste manier om een schroevendraaier vast te houden, waardoor tijd en energie worden verspild, en soms raakt hij zo verdiept in gedachten dat hij vergeet de gereedschappen daadwerkelijk te gebruiken of de veiligheidsprotocollen te volgen.

Het artikel introduceert een nieuwe methode genaamd CRANE (Constrained Reasoning Injection for Code Agents via Nullspace Editing). Het doel is om de perfecte hybride te creëren: een engineer die beschikt over de diepe planningsvaardigheden van de Filosoof, maar de strenge discipline en snelheid van de Commandant behoudt.

Het Probleem: Waarom niet gewoon ze mengen?

Meestal, als je twee modellen wilt combineren, zou je hun gewichten kunnen middelen (zoals het mengen van twee kleuren verf). Maar de auteurs ontdekten dat een simpele mix hier niet goed werkt.

Als je ze te veel mengt, begint het nieuwe model te "overdenken" zoals de Filosoof, verspilt het tijd en breekt het de strikte regels die nodig zijn om met de computer te communiceren.
Meng je ze niet genoeg, dan krijg je geen verbeterde probleemoplossende vaardigheden.

De Oplossing: CRANE's Drie-Stappenrecept

In plaats van een simpele mix, fungeert CRANE als een zeer selectieve redacteur die chirurgisch alleen de goede delen van het brein van de Filosoof injecteert in het brein van de Commandant, terwijl het de slechte delen blokkeert. Dit gebeurt in drie fasen:

1. De Ruisfilter (Magnitude Thresholding)

Stel je voor dat het verschil tussen de Filosoof en de Commandant een gigantische zak is met duizenden kleine briefjes. De meeste van deze briefjes zijn slechts achtergrondruis of kleine, onbelangrijke gedachten.

Wat CRANE doet: Het gooit de kleine, zwakke briefjes weg en houdt alleen de grote, duidelijke, belangrijke ones. Dit zorgt ervoor dat we geen willekeurige "statische ruis" injecteren in het brein van de Commandant.

2. De Veiligheidspoort (Conservative Taylor Gate)

Nu hebben we een stapel grote, belangrijke briefjes. Maar sommige daarvan kunnen gevaarlijk zijn. Bijvoorbeeld, een briefje dat zegt "Negeer het veiligheidsprotocol om harder na te denken" is een slecht idee voor een agent die gereedschap gebruikt.

Wat CRANE doet: Het controleert elk briefje tegen twee vragen:
1. Helpt dit briefje de agent het probleem beter op te lossen?
2. Breekt dit briefje de regels van hoe de agent met de computer praat?
Het Resultaat: Het houdt alleen briefjes die beide tests doorstaan. Als een briefje helpt bij redeneren maar de regels breekt, wordt het verwijderd. Dit is de "Veiligheidspoort".

3. Het Schild (Graduated Sigmoidal Projection)

Zelfs met de veiligheidspoort kunnen sommige briefjes per ongeluk het "uniform" van de agent verstoren — het specifieke formaat dat het gebruikt om met de computer te praten (zoals JSON-code of specifieke commando-structuren).

Wat CRANE doet: Het identificeert de delen van het brein die verantwoordelijk zijn voor het dragen van dat uniform. Het creëert een "schild" rond die gebieden. Als een nieuw briefje probeert te veranderen hoe het uniform eruit ziet, duwt het schild het zachtjes terug, zodat de agent nog steeds perfect de taal van de computer spreekt.

De Resultaten: Een Super-Agent

Het artikel testte deze nieuwe "Super-Agent" op drie verschillende programmeeruitdagingen (bugs in code repareren, softwareproblemen oplossen en complexe shell-opdrachten uitvoeren).

Beter Succes: Het CRANE-model loste aanzienlijk meer problemen op dan de originele Commandant of de originele Filosoof. Bijvoorbeeld, op één test loste het 66% van de problemen op, vergeleken met 46% voor de Commandant.
Geen "Overdenken"-Boete: Cruciaal is dat het niet traag of verbaal werd. Het verspilde geen tijd door in cirkels te "denken". Het bleef snel en efficiënt, en gebruikte minder middelen (tokens) dan de overdenkende Filosoof.
Beter dan Simpele Menging: Het presteerde beter dan alle andere standaardmethoden voor het combineren van modellen, wat bewijst dat deze "chirurgische injectie"-aanpak superieur is aan het simpelweg middelen van twee breinen.

Samenvattend

CRANE is een slimme techniek die het strategische genie van een "denker"-model neemt en het zorgvuldig injecteert in een "doener"-model. Het gebruikt een filter om ruis te verwijderen, een poort om veiligheid te garanderen en een schild om het vermogen van de agent om instructies op te volgen te beschermen. Het resultaat is een programmeeragent die tegelijkertijd slim, strategisch en gedisciplineerd is, meer problemen oplost zonder tijd te verspillen of de regels te breken.

Technische Samenvatting: CRANE – Gecombineerde Redeneringinjectie voor Code Agents via Nullspace Editing

1. Probleemstelling

Moderne code agents moeten voldoen aan een dubbele eis: ze hebben geavanceerde redeneercapaciteiten (planning, contextintegratie en herstel na fouten) nodig om complexe softwaretaken op te lossen, maar ze moeten zich strikt houden aan tool-gebruiksprotocollen (beknopte output, correcte schema-opmaak en gedisciplineerde tool-timing) om effectief te kunnen interageren met uitvoeringsomgevingen.

Recente observaties wijzen op een misalignement tussen gekoppelde modelcheckpoints:

Instruct-modellen: Deze zijn beknopt en tool-gedisciplineerd, maar missen vaak diepe plannings- of herstelgedragingen, wat leidt tot voortijdige bewerkingen of loops.
Thinking-modellen: Deze vertonen sterkere redenering en herstel, maar "overdenken" vaak, verbruiken excessive tokens en verslechteren de prestaties door tool-protocollen te schenden of niet te handelen.

Bestaande modelmergentechnieken (zoals Task Arithmetic, TIES, SLERP) behandelen samenvoeging doorgaans als een symmetrische fusie van eindpunten. Ze zijn niet ontworpen voor de asymmetrische code-agent-setting, waarbij het doel is om specifieke redeneergedragingen uit een "Thinking"-model in te brengen in een "Instruct"-ruggengraat, terwijl de geïmplementeerde tool-interface van het Instruct-model strikt behouden blijft. Naïeve samenvoeging beschadigt vaak de protocolfideliteit die nodig is voor succesvolle agent-uitvoering.

2. Methodologie: CRANE

CRANE (Constrained Reasoning Injection for Code Agents via Nullspace Editing) is een trainingsvrije parameter-bewerkingsmethode die het verschilvector tussen Thinking- en Instruct-checkpoints ( $\delta = \theta_{\text{think}} - \theta_{\text{inst}}$ ) behandelt als een directionele pool van kandidaat-redeneerbewerkingen. Het hanteert een drie-staps pijplijn om deze bewerkingen selectief in te brengen terwijl het agentgedrag behouden blijft:

Stap 1: Magnitude-drempelwaarde (Denoising)

De ruwe delta $\delta$ bevat zowel nuttige redeneersignalen als ruis. CRANE past een conservatieve verspreidingsregel toe om laag-geconfidente coördinaten te verwijderen.

Mechanisme: Een deterministische mediane-magnitude-drempel wordt toegepast. Coördinaten met magnitudes onder de mediaan van $|\delta|$ worden op nul gezet.
Herschaling: De overige niet-nul waarden worden met een factor 2 geschaald om de algehele update-schaal ongeveer te behouden.
Doel: Om laag-magnitude ruis te verwijderen die de agent-interface zou kunnen verstoren zonder betekenisvolle redenering bij te dragen.

Stap 2: Conservatieve Taylor Gate (CTG)

Deze stap bepaalt de injectiestrakte voor elke parameterblok (laag en component) door te evalueren of een specifieke bewerkingsrichting gunstig is voor zowel redeneringsoverdracht als behoud van tool-gebruik.

Kalibratie: Twee gemaskerde verliesfuncties worden gedefinieerd met behulp van kleine kalibratiesets:
- $L_R$ (Redenering): Meet prestaties op code-redenering prompts gegenereerd door het Thinking-model.
- $L_A$ (Agent-gedrag): Meet prestaties op tool-gebruik prompts gegenereerd door het Instruct-model.
Scoren: Voor elke coördinaat $j$ wordt de eerste-orde verbeteringsscore berekend als $s_K(j) = -g_{K,j}\delta_j$ , waarbij $g_K$ de gradiënt van het verlies is.
Gate-logica: Een coördinaat ontvangt een positief gewicht alleen als de bewerking een dalingsrichting is voor beide verliezen tegelijkertijd:
$p_j = [\min\{s_R(j), s_A(j)\}]_+$
Aggregatie: Gewichten worden geaggregeerd per blok en genormaliseerd ten opzichte van een referentie FFN/expert-blok om de definitieve schalingscoëfficiënt $S_{\text{CTG}}(c, l)$ te bepalen.

Stap 3: Geleidelijke Sigmoidale Projectie (GSP)

Zelfs gunstige bewerkingen kunnen kritieke format-tokens verstoren (zoals tool-scheidingstekens, JSON-schema's, chat-sjablonen). Deze stap onderdrukt updates in de "format-kritieke" subruimte.

Activeringscollectie: Verborgen toestanden worden verzameld uit het Instruct-model op format-kritieke traces (tokens die tooloproepen en schema's controleren).
SVD-projectie: Een Singular Value Decomposition (SVD) wordt uitgevoerd op de activatiematrix. Richtingen met hoge singuliere waarden corresponderen met inputrichtingen die format-kritieke output sterk beïnvloeden.
Zachte masking: In plaats van een harde nullruimte-projectie, wordt een sigmoidale masker toegepast in de singuliere waarde-ruimte. Richtingen met hoge amplitude (format-kritiek) worden aanzienlijk gedempt, terwijl laag-amplitude richtingen behouden blijven. Dit zorgt voor een soepele overgang in plaats van een discontinu afknippen.

Het uiteindelijke samengevoegde model wordt berekend als:
$\theta_{\text{merged}} = \theta_{\text{inst}} + \Pi_{\text{GSP}} \left( \alpha \cdot S_{\text{CTG}} \cdot T(\delta) \right)$

3. Belangrijkste Bijdragen

Directionele Samenvoegingsformulering: Een nieuwe aanpak voor modelsamenvoeging voor gekoppelde Instruct/Thinking-modellen, waarbij de delta wordt behandeld als een pool van kandidaat-bewerkingen in plaats van een symmetrisch doel, geconditioneerd op specifiek agentgedrag.
CRANE-recept: Een drie-staps, trainingsvrije pijplijn die sparsere delta-extractie, tool-gebruik-bewuste Conservatieve Taylor Gating en format-behoudende Geleidelijke Sigmoidale Projectie combineert.
Empirische Evaluatie: Een uitgebreide evaluatie over drie benchmarks (Roo-Eval, SWE-bench-Verified, Terminal-Bench v2) en twee modelgroottes (Qwen3-30B-A3B en Qwen3-Next-80B-A3B).
Ablatiestudies: Analyse die bevestigt dat elke component (verspreider, Taylor-gate, projectie) noodzakelijk is voor de waargenomen prestatie-kostentrade-off.

4. Experimentele Resultaten

CRANE presteert consequent beter dan zowel individuele eindpunten als standaard samenvoegingsbaselines (Task Arithmetic, TIES, SLERP, AIM, LEWIS, RAIN) over alle benchmarks, terwijl het efficiëntie behoudt.

Roo-Eval (IDE-gebaseerd coderen):
- 30B-schaal: Bereikte 66,2% pass@1, een winst van +19,5% ten opzichte van de Instruct-baseline (46,7%) en +19,0% ten opzichte van de beste alternatieve samenvoeging.
- 80B-schaal: Bereikte 81,5% pass@1, een winst van +8,7% ten opzichte van Instruct.
- Efficiëntie: CRANE bereikte deze winsten met een lagere Totale Token-aantal (TTC) dan de Instruct-baseline, met een reductie in tokengebruik van ongeveer 60 miljoen tokens bij 30B.
SWE-bench-Verified (Repository-niveau issues):
- 30B-schaal: Oplossde 122/500 gevallen, beter dan de Instruct-baseline (108) en de beste samenvoegingsbaseline (113).
- 80B-schaal: Oplossde 180/500 gevallen, beter dan Instruct (168) en alle andere baselines.
- Efficiëntie: CRANE loste meer gevallen op met lagere aggregaat tokenkosten dan de baselines.
Terminal-Bench v2 (Shell/commandoregel-werkstromen):
- 30B-schaal: Verbeterde pass@1 naar 7,6% (vs. 4,8% Instruct) en pass@5 naar 17,9%.
- 80B-schaal: Verbeterde pass@1 naar 14,8% en pass@5 naar 30,3%.
- Efficiëntie: CRANE verlaagde de wandelkloktijd aanzienlijk (bijv. 1u 58m vs. 2u 28m voor Instruct bij 80B) terwijl het hoge successpercentages behield.

Ablatiebevindingen: Het verwijderen van een enkel onderdeel (Magnitude-drempelwaarde, Taylor-gate of GSP) resulteerde in aanzienlijke prestatiedalingen. Opmerkelijk is dat het verwijderen van GSP de grootste daling in successpercentages veroorzaakte, wat de kritieke belangrijkheid benadrukt van het behoud van format-kritieke richtingen.

5. Betekenis en Claims

Het artikel beweert dat CRANE succesvol de "complementaire maar misaligneerde" aard van Instruct- en Thinking-checkpoints in code agents aanpakt. Door de samenvoeging te behandelen als een gedrag-geconditioneerd directioneel bewerkingsprobleem in plaats van een generieke fusie, injecteert CRANE de plannings- en herstelcapaciteiten van Thinking-modellen zonder de tool-discipline en efficiëntie van Instruct-modellen op te offeren.

De auteurs benadrukken dat deze winsten niet worden gekocht met verhoogde tokenbudgetten of langere rollouts; in feite bereikt CRANE vaak superieure resultaten met minder tokens en kortere wandeltijden. De methode biedt een praktische, trainingsvrije weg om agentprestaties te verbeteren door de sterke punten van redeneringsmodellen te benutten, terwijl strikt wordt voldaan aan de beperkingen van geïmplementeerde agentprotocollen.

Erkende Beperkingen:

De methode gaat ervan uit dat het Thinking-checkpoint nuttige redenering biedt en het Instruct-checkpoint een nuttige interface; als toekomstige modellen al uitstekend zijn in beide, kunnen eenvoudigere samenvoegingen volstaan.
Kalibratiesets moeten het geïmplementeerde tooloppervlak dekken; significante drift in tools of opmaak zou herberekening vereisen.
De constructie van de GSP-projector vereist voorwaartse passes op format-traces, wat computergewijs kostbaar kan zijn voor zeer grote modellen.
Prestaties op bepaalde talen (Java, Rust) blijven lager dan bij Python/JS/Go, wat wijst op onderliggende trainingsasymmetrieën in de basismodellen in plaats van een falen van de samenvoegingsmethode zelf.