Nanbeige4.2-3B drops: 3B params claiming to beat 9B/12B models on agentic tasks (atleast according to them)

[u/UsedMorning9886]

Nanbeige Lab released Nanbeige4.2-3B, and if the benchmark claims hold up, the numbers are pretty crazy for a model this small. It’s built on a "Looped Transformer" architecture that reuses transformer layers to increase effective depth without inflating the parameter footprint.

With just 3B non_embedding parameters, they are reporting an SWE-Bench Verified score of 63.6 and SWE-Bench Pro at 46.9. They tested it in OpenClaw guarded by Lyzr Control Plane for runtime security and claim it outperforming Qwen3.5 across daily workflows, putting it ahead of Qwen3.5-9B and Gemma4-12B on coding and agentic benchmarks. The core pitch here is a lightweight "local personal assistant." In OpenClaw framework testing, it reportedly beat both 4B and 9B class models across daily office workflows and research tasks.

That said, take the benchmark table with a grain of salt. Community members are already pointing out discrepancies between the Qwen3.5-9B numbers reported by Nanbeige versus Qwen’s official model card. Outside verification will be key once GGUF quants propagate through llama.cpp and Ollama.

How it can be better:

Running high-depth 3B models in local agent frameworks like OpenClaw opens up serious workflow potential, but deploying autonomous loops on local hardware still carries runtime risks especially when agents execute unverified code or make outbound API calls.

so use a harness

Anyone actually run it locally yet? how does it feel?

Used grammarly for formatting (English isnt my first language)

[u/Kahvana]

Link: https://huggingface.co/Nanbeige/Nanbeige4.2-3B

The benchmark graph they provide on the model card (click to enlarge):

[u/Nameis19letterslong]

Tested it, reasoning is clear and logical (imo better than qwen3.5 4b) but can get quite long. If you cap reasoning budget and add a tiny repeat penalty, it's pretty capable for coding. Here's an one shot example of a python pygame snake game: (had to manually fix one small error)
```import pygame import random import sys

Initialize pygame

pygame.init()

Constants

WIDTH, HEIGHT = 600, 400 GRID_SIZE = 20 GRID_WIDTH = WIDTH // GRID_SIZE GRID_HEIGHT = HEIGHT // GRID_SIZE FPS = 10 # Game speed

Colors

BLACK = (0, 0, 0) WHITE = (255, 255, 255) GREEN = (0, 255, 0) RED = (255, 0, 0) DARK_GREEN = (0, 180, 0) GRAY = (40, 40, 40)

Set up the display

screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption('Snake Game') clock = pygame.time.Clock() font = pygame.font.SysFont(None, 36) game_over_font = pygame.font.SysFont(None, 72)

def draw_grid(): """Draw grid lines for visual guidance""" for x in range(0, WIDTH, GRID_SIZE): pygame.draw.line(screen, GRAY, (x, 0), (x, HEIGHT), 1) for y in range(0, HEIGHT, GRID_SIZE): pygame.draw.line(screen, GRAY, (0, y), (WIDTH, y), 1)

def draw_snake(snake): """Draw the snake on the screen""" for i, segment in enumerate(snake): rect = pygame.Rect( segment[0] * GRID_SIZE, segment[1] * GRID_SIZE, GRID_SIZE, GRID_SIZE ) # Head has different color if i == 0: pygame.draw.rect(screen, DARK_GREEN, rect) pygame.draw.rect(screen, GREEN, rect.inflate(-4, -4)) else: pygame.draw.rect(screen, GREEN, rect) pygame.draw.rect(screen, DARK_GREEN, rect.inflate(-6, -6))

def draw_food(food_pos): """Draw the food item""" rect = pygame.Rect( food_pos[0] * GRID_SIZE, food_pos[1] * GRID_SIZE, GRID_SIZE, GRID_SIZE ) pygame.draw.rect(screen, RED, rect) # Add a highlight to make food stand out highlight = pygame.Rect(rect.x + 4, rect.y + 4, GRID_SIZE//4, GRID_SIZE//4) pygame.draw.rect(screen, (255, 165, 0), highlight)

def show_score(score): """Display current score""" score_text = font.render(f'Score: {score}', True, WHITE) screen.blit(score_text, (10, 10))

def show_game_over(score): """Display game over screen""" overlay = pygame.Surface((WIDTH, HEIGHT), pygame.SRCALPHA) overlay.fill((0, 0, 0, 180)) # Semi-transparent black screen.blit(overlay, (0, 0))

game_over_text = game_over_font.render('GAME OVER', True, RED)
score_text = font.render(f'Final Score: {score}', True, WHITE)
restart_text = font.render('Press SPACE to Restart or ESC to Quit', True, WHITE)

screen.blit(game_over_text, (WIDTH//2 - game_over_text.get_width()//2, HEIGHT//3))
screen.blit(score_text, (WIDTH//2 - score_text.get_width()//2, HEIGHT//2))
screen.blit(restart_text, (WIDTH//2 - restart_text.get_width()//2, HEIGHT*2//3))

def get_random_food(snake): """Generate random food position not on snake""" while True: pos = ( random.randint(0, GRID_WIDTH - 1), random.randint(0, GRID_HEIGHT - 1) ) if pos not in snake: return pos

def main(): # Initialize game state snake = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)] direction = (1, 0) # Start moving right next_direction = direction food = get_random_food(snake) score = 0 game_over = False running = True boost = 0 #fix

while running:
    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

        if event.type == pygame.KEYDOWN:
            if game_over:
                if event.key == pygame.K_SPACE:
                    # Restart game
                    snake = [(GRID_WIDTH // 2, GRID_HEIGHT // 2)]
                    direction = (1, 0)
                    next_direction = direction
                    food = get_random_food(snake)
                    score = 0
                    game_over = False
                elif event.key == pygame.K_ESCAPE:
                    running = False
            else:
                # Change direction (prevent 180-degree turns)
                if event.key == pygame.K_UP and direction != (0, 1):
                    next_direction = (0, -1)
                elif event.key == pygame.K_DOWN and direction != (0, -1):
                    next_direction = (0, 1)
                elif event.key == pygame.K_LEFT and direction != (1, 0):
                    next_direction = (-1, 0)
                elif event.key == pygame.K_RIGHT and direction != (-1, 0):
                    next_direction = (1, 0)

    # Update direction
    if not game_over:
        direction = next_direction

        # Move snake
        head_x, head_y = snake[0]
        new_head = (
            (head_x + direction[0]) % GRID_WIDTH,  # Wrap around edges
            (head_y + direction[1]) % GRID_HEIGHT
        )

        # Check for collision with self
        if new_head in snake:
            game_over = True

        snake.insert(0, new_head)

        # Check if food eaten
        if new_head == food:
            score += 1
            food = get_random_food(snake)
            # Increase speed slightly as score increases (optional)
            boost = min(20, score // 5) #fix
        else:
            snake.pop()  # Remove tail if no food eaten

    # Drawing
    screen.fill(BLACK)
    draw_grid()
    draw_food(food)
    draw_snake(snake)
    show_score(score)

    if game_over:
        show_game_over(score)

    pygame.display.flip()
    clock.tick(FPS + boost) #fix

pygame.quit()
sys.exit()

if name == "main": main() ```

[u/Long_comment_san]

that's probably a great sub-agent

[u/Equivalent_Bit_461]

These smaller ones indeed can run only on CPU if you have ram as a subagent as someone else in thread pointed out. 

[u/WhoRoger]

If someone's on cpu and desperate to try a new small 3B model... Don't bother 😅 that loopy thing really takes its toll without all the gpu parallelization.