How to run Groot-19B-A3B-261023 MTP on RTX 4070 SUPER + RTX 4060 Ti

Warning: this is a temporary briefing, written by an LLM and not yet evaluated or rewritten by a human to get rid of the signature AI-slop writing style. It’s published as a draft despite its shortcomings, so that you can find out how to run it and what to expect in terms of pp and tg on this hardware, as well as what to expect in terms of coding performance on this benchmark, grosso modo.

Groot-19B-A3B-261023 MTP Q5_K_M demonstrated perfect (30/30) needle recall across the full served 262144-token context window, the fastest spec-decode among the models measured on this box (embedded-MTP acceptance 62-68%), and proper ```elixir fences in all three runs, perfectly fulfilling the output contract of the v5 benchmark. However, it still missed the compile gate 0/3 with more issues than merely a typo: the modules mix Python block syntax (unless cond with no do) with heredoc and one-liner issues, and run 3 keeps failing even after the heredocs are mechanically repaired. Review quality is the best measured on this hardware so far, but code output is not ready to compile.

Representative output

Run 3 of the benchmark delivered the cleanest, most complete module of the batch, with full @spec coverage on the public API and a timer-driven eviction loop. Trimmed excerpt of the public API:

defmodule TtlStore do
  @spec start_link(map()) :: pid
  def start_link(opts) when is_map(opts) do
    ttl = Map.get(opts, :ttl, 3600)
    validate_ttl!(ttl)
    state = make_state(ttl)
    {pid, _ref} = Process.spawn_linker(fn s -> loop(s) end, state)
    pid
  end

  @spec start_link(binary(), integer()) :: pid
  def start_link(name, ttl) when is_binary(name), is_integer(ttl) do
    start_link(%{name: name, ttl: ttl})
  end

  @spec put(pid, binary(), binary()) :: atom()
  def put(pid, key, value) do
    validate_key!(key)
    validate_value!(value)
    send_cmd(pid, {:put, key, value})
  end

  @spec put(pid, binary(), binary(), integer()) :: atom()
  def put(pid, key, value, ttl) do
    validate_key!(key)
    validate_value!(value)
    validate_ttl!(ttl)
    send_cmd(pid, {:put, key, value, ttl})
  end

  @spec get(pid, binary()) :: {atom(), binary()}
  def get(pid, key) do
    validate_key!(key)
    send_cmd(pid, {:get, key})
  end

  @spec delete(pid, binary()) :: atom()
  def delete(pid, key) do
    validate_key!(key)
    send_cmd(pid, {:delete, key})
  end

  @spec stats(pid) :: map()
  def stats(pid) when is_pid(pid) do
    send_cmd(pid, :stats)
  end
end

The catch

The delivered-pipeline gate is 0/3 as-filed, with three distinct issues, each one in its own defect class:

• run 1 kv_1.ex:2:17 — inline @moduledoc heredoc (triple-quote content on the opening line).
• run 2 kv_2.ex:13:73 — a ;-joined one-liner def f(_x); … end plus the Python raise(ArgumentError, …) call-shape.
• run 3 kv_3.ex:4:15 → post-patch 33:5 — inline heredoc, then a do/end imbalance (unless cond written without do) that survives a mechanical heredoc repair.

The issue runs two levels deep: cosmetic tokens and real block structure. Format discipline held across all three runs (proper ```elixir fences), fulfilling the benchmark prompt’s output contract). However, the model’s output requires genuine editing by the orchestrator model that goes beyond small changes.

Route

It’s worth promoting Groot to long-context retrieval and review duty, but keep a compile gate and a “lint your output” instruction to the orchestrator in front of it. This is not a drop-in subagent model for Elixir coding that will require no orchestration, and can therefore not be used as a primary model for that purpose either.