Debugger

Watch the CPU inside the model run a tool call.

Qwen3.5-4B writes a <tool_call>. Thirteen extra layers in its weights, a 64-bit x86 computer that a compiler wrote and nobody trained, run the tool and write the answer back into the chat. Pick a run and press play.

Get the model: Quazim0t0/Qwenx86-4B-compact →

Conversation

The machine

x86-64

Registers

Code

    RAM · 64 KB 1 px = 1 byte · just written written

    Output what the firmware prints: the tool response

    
      
    
    
    
  
    

    


    
  
    New in v2 and v3
    
  
    Memory: what the model can store and give back exactly
    
  
    The same model, with memory slots next to four of its layers. Everything below was recorded
    on the released model; Qwen's own answers stay exactly the same whether the memory is full or empty.
    The memory is run by Python code beside the model (v2); in v3, Qwen uses it through tools it calls itself.
    
  

  
    
    
    
      
    
        
    Operations
    
        
    
          
    
        
      
      
      
      
      
        
      Memory slots
      
           written now  read now  holds data
      
        
        
      Each square is one memory slot (2,048 per layer). Layer 13 holds the directory (file names), layer 14 the first pieces of text; layers 15-16 fill up only with long files, so they stay dark in this short session.
      
        
      Result
      Press play.
      
      
      
    
      
  
      

  

  

  

  

  

      


      
  
      How a tool call runs
      
  
        
    
      1. Qwen writes the call. Ordinary text: <tool_call> … </tool_call>.
      The computer's layers capture its bytes as Qwen writes them.
        2. 
    
      2. The firmware runs. Each tool (calculator, MicroPython, a C compiler, notes, science and
      Python-docs lookups) is firmware baked into the checkpoint. The x86 core executes it one machine token at a time.
        3. 
    
      3. Every token is checked. A reference machine knows the run in advance, so the model's own chip layers
      verify up to 256 machine tokens per batched pass (block verify, the bands on the timeline). Every token matched.
        4. 
    
      4. The answer comes back as text. The firmware prints the tool response in Qwen's chat format,
      and Qwen answers from it.
        5. 
  
      
  
      Recorded on one 16 GB GPU with the compact Qwenx86 checkpoint, using greedy decoding. The registers, code and
    RAM are the reference machine replaying each run.
      
  
      The x86 side comes from my Zen2 research. The CPU circuit is forked from
    Qwenputer by Divyansh Agrawal (MIT),
    whose compiler, tool-call bridge and chat loop Qwenx86 builds on. Base model: Qwen/Qwen3.5-4B.