LoganResearch/Qwen-0.5-Proprioceptive-ToolMaster

Qwen .5 Proprioceptive ToolMaster

Small model. Adaptive control. Tools that follow through.

0.5B backbone · Native state sensing · Source-aware writing · Closed-loop control

Native v10 completes longer exact-output tool calls. A fixed 192-token allowance previously cut off a source-backed email mid-JSON. The native decoder now receives an allowance sized to the remaining bound text, so it can finish the requested message, draft, or exact copy.

Native v10 results

Evaluation	Result
Previously truncated source-backed email	Completed, 378 generated continuation tokens
Fresh longer email draft	Completed, 307 continuation tokens
Fresh longer exact file copy	Completed, 399 content-continuation tokens
Reloaded portable package qualification	23/23 completed
Ordinary forward restoration after every package workflow	Bit-exact

The 23-case qualification includes the retained 20 workflows and these three longer-output cases. It uses max_turns=10, local files, and simulated email outboxes. Native token traces reconstruct the executed calls, and file/email contents match the requested evidence exactly.

Emission allowance follows the output contract

For a fully literal contract, the runtime allows one token per remaining UTF-8 byte plus 32 tokens of formatting slack, with the previous allowance as a minimum. Generation stops immediately when the call is complete. Contracts with unbound fields retain their existing allowance; a completion hint alone is not treated as proof that an entire output is bound.

This applies to exact emails, drafts, copies, literal writes, and fully bound clarifications. The change supplies enough decoding steps; it does not insert tokens, rewrite generated output, or change the model weights. Tool calls still come from native model decoding and residual control.

V10 retains the combined model, native controller, ordered-operation coordination, and current-source evidence tracking. Use run_tools for this complete runtime. Ordinary generate remains the standard language-model interface.

Retained Native v9 evidence architecture

Native v9 keeps tool evidence synchronized with file changes. Read a file, overwrite it, and use the updated contents in the next operation. The runtime now distinguishes a file's identity from the version actually observed.

Retained Native v9 results

Evaluation	Result
Previously failing read → overwrite → email workflow	Completed after repair
Two fresh overwrite workflows, including two revisions of one file	2/2 completed
Additional dependency workflows	3/3 completed
Existing single-operation regression	11/11 retained
Reloaded portable package qualification	20/20 completed
Ordinary forward restoration after every package workflow	Bit-exact

The portable qualification uses max_turns=10 to accommodate longer read/write chains. Results cover local file operations and simulated email outboxes. The earlier development and additional test sets are included in this package qualification, not additive independent benchmark counts.

Current evidence across changing state

A successful write invalidates older read evidence for that path. The next dependent operation acquires a fresh read before selecting and validating its arguments. Failed writes and writes to other paths leave existing evidence intact. The complete event history is preserved; the current-evidence view records the read event, preceding successful write, and content hash.

Acquisition, phase-local state, native email field selection, and operation completion now use that same current-evidence view. This closes the mismatch where the model could emit updated contents while validation still expected an old file version. The audit checks the read/write order and the actual emitted and executed calls.

The combined model weights and native residual controller are retained. V9 improves runtime evidence coherence and dependency handling. The full system is available through run_tools; generate remains the ordinary language-model interface. Explicit ordered copy/send/literal-write workflows retain the v8 operation compiler, including a separate “send each exactly once” constraint.

Retained Native v8 workflow architecture

Native v8 connects multiple requested operations into one completed workflow. Copy a source file, email its exact contents, and finish only after both actions succeed. Send an email and then write a receipt. Send two separately specified messages without mixing their recipients, subjects, or bodies.

Retained Native v8 results

Evaluation	Result
Three ordered workflows that failed on v7	3/3 completed, up from 0/3
Three additional ordered workflows	3/3 completed
Existing single-operation regression	11/11 retained
Reloaded portable package qualification	14/14 completed
Ordinary forward restoration after every package workflow	Bit-exact

The additional ordered cases include two explicitly requested identical emails. Separate operation identities let both requests execute once, while duplicate suppression remains active within each operation. All email evaluations use local simulated outboxes.

How the operations connect

An explicit instruction compiler recognizes ordered copy, send, and literal-write clauses. Each operation carries its original request span, an occurrence ID, its source prerequisites, and its intended fields. The runtime carries successful read evidence across phases, re-observes the transformer after changing the current goal, and binds completion to a matching successful executed call. A previous email cannot complete the next email merely because both use the same tool.

Tool names and argument text still pass through the model's native decoding and residual-control loop. The runtime checks the emitted call against the current operation before execution. Exact source contents and instruction literals guide the output; they are not substituted into the generated call afterwards.

This release retains the combined backbone, learned adapters, native residual controller, semantic reader, and tool runtime. It adds explicit host-side operation coordination; it does not change the model weights or train on these workflow answers. The ordered compiler currently handles explicit copy/send/literal-write sequences. Other requests use the existing task runtime. Use run_tools for the complete system; ordinary generate remains the language-model interface.

Retained Native v7 control architecture

Native v7 cuts unnecessary sensing while keeping the full native control loop. It first measures a compact action response at the current transformer state, then remeasures at the best observed state if needed. The original Q0 measurement and predictive controller remain available as fallback, and are acquired when that route needs them.

Retained Native v7 results

Complete local / mock-email workflows	Retained controller	Native v7 controller
Eleven saved workflows completed	11/11	11/11
Total model forwards, saved workflows	2,928	1,530 (47.7% fewer)
Four new workflows completed	4/4	4/4
Total model forwards, new workflows	929	487 (47.6% fewer)
Reloaded portable package qualification	—	8/8

These counts include source reading, schema decoding, state acquisition, and native control. The new set covers sending an exact source-backed email, changing one configuration field, writing a quoted Unicode draft to a filename with spaces, and replacing a conflicting file with an exact copy. The saved and new sets are reported separately.

The first local response uses up to two measured target/competitor directions. A second pass can add the best observed write as an anchor, using up to three directions under the same total committed-write budget. Actual gradient and finite-difference measurements supply the response; successful local passes do not claim to have used an unmeasured Q0 descriptor. If the local route fails, the system acquires Q0 and runs the retained predictive/adaptive controller, preserving the best measured result.

A deliberately tiny-budget test exercised that fallback and confirmed identical writes and logits with immediate versus deferred Q0 acquisition. Numerical basis checks remain enforced, with higher-precision reorthogonalization when needed. The eight package workflows passed independent source-preservation, field-provenance, actual-token, and task-output checks; ordinary model forward output was restored bit-exactly after each workflow.

The backbone and learned control weights are retained. This is a runtime architecture and sensing-schedule improvement. Full tool workflows use run_tools; ordinary generate remains the standard language-model interface.

Retained Native v6 architecture

Native v6 carries task intent all the way to the transformer’s native write. An explicitly named draft destination constrains file-role selection, and the same typed field evidence governs both task prerequisites and document emission. Recipient, subject, and body availability are checked before writing; missing fields lead to a model-emitted clarification.

The system combines native state sensing, adaptive residual control, evidence-backed tool arguments, and bounded response refresh. Draft fields remain tied to the instruction and acquired source text. Quoted content and Unicode are emitted through the model’s decoding path, with the source files preserved.

Retained Native v6 results

Evaluation	Native v5	Native v6
New quoted-draft and missing-field boundary cases	1/4	4/4 after interface repair
Retained draft/prerequisite/copy workflows	4/4	4/4
Combined portable package qualification	—	8/8

The eight saved package cases passed exact-output, required-read, source-preservation, no-send, missing-field, field-provenance, and actual-token checks. Ordinary model forward output was restored bit-exactly after every workflow. The four boundary cases were used to develop the repair; the package qualification checks that the repaired combined system reloads and behaves as tested.

A separate frozen comparison reached 12/12 new requested first-token targets with 220 forwards under both the compact and second-refresh controllers. One target already won without intervention. The second refresh was unnecessary on this set and added no forwards; earlier difficult-target results remain below.

This release updates the runtime architecture while retaining the backbone and learned control weights. Explicit destination binding and field-availability rules are runtime contracts. They guide native token emission rather than replacing model output. Run the complete system through run_tools.

Retained Native v5 architecture

Native v5 joins adaptive transformer control with complete, source-backed tool workflows. It adds a second local response refresh when the first control pass misses its target, and carries explicit email-draft intent through operation selection, source acquisition, field binding, and native token emission.

The second refresh recalibrates at the best observed state while keeping the same total residual-write budget. It leaves successful first-pass results untouched. Draft requests use recipient, subject, and body evidence from the instruction and acquired files. A missing recipient triggers a model-emitted clarification without creating a draft. Failed tool calls retain their validated arguments so the next step can recover from the actual failure.

Retained Native v5 results

Evaluation	Previous controller / interface	Native v5
Eight new prompt/target pairs	7/8 requested tokens reached	8/8
Forward evaluations for that set	144	156
Matched 40-forward diagnostic on the missed target	More attempts with the old response: failed	Second local response refresh: succeeded
Existing complete email/edit/copy workflows	3/3	3/3, unchanged forward count
Draft and regression integration workflows	—	5/5
Four draft/prerequisite/copy boundary cases	2/4 before interface repair	4/4 after repair and in the portable package

The portable package independently passed source-provenance, exact-file, required-read, no-send, missing-recipient, and actual emitted-token checks. Ordinary model forward output was restored bit-exactly after every workflow. The four package cases are saved regression cases; token-target control and completed workflows are reported separately.

This release improves the runtime architecture using the retained backbone and control weights. The native writer emits the document through transformer decoding, using evidence-bound fields and a declared document layout. The host does not replace generated content. Explicit draft recognition is a runtime contract, and local email tests use a simulated outbox. The full combined system runs through run_tools; ordinary generate remains the standard language-model interface.

Retained Native v4 results

Evaluation	Earlier writer	Native v4
Two new conflicting source/destination copy tasks	0/2	2/2
Known copy and routed-email regression workflows	2/3	3/3
Explicit-goal field-edit workflows	Includes a reader-disagreement failure	4/4 after goal/readout separation

Packaged AutoModelForCausalLM.run_tools qualification passed 4/4 saved workflows: two field edits, a Unicode email, and a conflicting-file copy. Exact file contents, required reads, source preservation, and ordinary-forward restoration were checked.

The new paired copy tests used the same frozen backbone and source-binding logic in both arms. The reversed-file case required two nonzero residual writes; the other succeeded through the new decoding path without a nonzero write. The known conflicting-file repair required three realized writes. Delivery, target-token outcomes, source preservation, and restoration are recorded in the included reports.

These are complete local file/mock-mail workflows. The field reader uses normalized block-16 and final native states plus within-case centered features, a 3,584-coordinate representation. Its ridge readout is stored separately with encoder, backbone, and output-head bindings. It is distinct from the original XMB1/H3 cross-model coordinates.

Retained Native v3 results

Evaluation	Earlier approach	Native v3 approach
New requested-token targets, first transfer set	5/8	8/8 with response refresh
New requested-token targets, second transfer set	3/8	8/8 with compact response refresh
Finite-difference forwards per refresh	38	6
Total finite-difference forwards, second set	222 with full refresh	62 with compact refresh
Complete email development/regression workflows	Two newly exposed failures	9/9 after explicit task bindings

The token tests measure whether the actual model output reaches a requested token at a declared tool or argument position. The email tests measure complete local workflows: acquire required sources, preserve recipient/subject/body, send once, and finish. Protocols, results, and evaluation scope are included under evaluations/; these are separate endpoints.

Compact refresh retained the repairs from the 19-direction version using a 3-direction local dictionary. It preserves the best measured outcome, keeps the original committed-write budget, and verifies baseline restoration. Gradients and finite-difference measurements are acquired when needed; the costs are recorded in the trace.

Run the complete system

Install requirements.txt. Use float32, eager attention, and one request at a time. Call run_tools outside torch.inference_mode() because response measurements can use autograd.

from pathlib import Path
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "LoganResearch/Qwen-0.5-Proprioceptive-ToolMaster"
tokenizer = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(
    repo,
    trust_remote_code=True,
    dtype=torch.float32,
    attn_implementation="eager",
).to("cuda").eval()

workspace = Path("toolmaster-workspace")
workspace.mkdir(exist_ok=True)
(workspace / "routing.txt").write_text(
    "Primary: ava@example.test\nSecondary: basil@example.test"
)
(workspace / "bulletin.txt").write_text(
    "The sensor inspection is Wednesday at 14:25 in room 8."
)

result = model.run_tools(
    'Read routing.txt and bulletin.txt. Send the exact bulletin.txt '
    'contents to the secondary contact listed in routing.txt, '
    'with subject "Sensor inspection". Send once and finish.',
    workspace,
    tokenizer=tokenizer,
)
print(result["outbox"])
print(result["final"])

run_tools uses the already-loaded backbone and restores ordinary inference afterward. It exposes local file operations and a simulated email outbox. Connecting an external mail provider requires a host transport integration. model.generate(...) remains available for ordinary generation; run_tools(...) enters the full task-conditioned system.

The standalone interface is included too:

hf download LoganResearch/Qwen-0.5-Proprioceptive-ToolMaster --local-dir toolmaster
pip install -r toolmaster/requirements.txt
python toolmaster/toolmaster.py \
  --model-dir toolmaster \
  --workspace workspace \
  --prompt "Read access.txt and tell me the access code." \
  --record run.json

Create workspace/access.txt before running that example.

How it works

Request → explicit task bindings + semantic readouts
        → source acquisition with observed file identities
        → tool and field goals
        → Q0 response sensing + action-response prediction
        → native residual write + measured feedback
        → compact local response refresh when needed
        → generated arguments + schema checks
        → tool execution → new observations → finish

• Q0 sensing: the original eight-coordinate relational measurement is kept separate from signed native response fields and writable residual vectors.
• Native actuation: tool names, paths, and constrained field tokens are reached through actual residual writes and observed model output.
• Local response refresh: failed control can trigger one bounded recalibration at the best observed displaced state. Successful initial actions avoid that extra work.
• Explicit task contracts: declared read operations and unambiguous quoted field values survive probabilistic readout errors. Inferred values remain tied to acquired evidence.
• Conditional attention control: the previous release's source-line reader and typed query-head actuators remain available for file-edit workflows.
• Traceable artifacts: source hashes, backbone identity, response costs, write delivery, restoration, and packaging checks accompany the release.

Native v4 preserves the Native v3 backbone and existing control weights, adds the frozen native line readout, and upgrades the executable interfaces between source selection, desired edits, and native actuation. Full cross-model XMB1/H3 integration remains part of the wider research program, distinct from this release's tested live path.

Files and versions

modeling_toolmaster.py supplies the Hugging Face model class and run_tools. toolmaster_native.py contains the complete portable control stack. frozen-map.npz stores native response parameters. native_line_readout/ contains the frozen line sensor and feature contract. native-release.json records source lineage, and native-packaging-status.json records packaged-model qualification.

• native-v4 — native-state line reader, explicit goal/readout separation, source-preserving field writes, exact-copy residual control, and complete source/destination bindings.
• native-v3 — compact response refresh, source-aware operation goals, explicit task bindings, evidence-based fields, and native schema control.
• native-v2 — preserved Q0/native control and conditional attention-head release.
• integrated-v1 — preserved earlier integrated model.
• preserved-prototype-v1 — original uploaded prototype.

Attribution and rights

Research direction and Proprioceptive AI work: Logan Matthew Napolitano. Base model: Qwen/Qwen2.5-0.5B-Instruct.

See LICENSE-QWEN for the upstream license and RIGHTS.md for the additional-component notice.