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

> Source: <https://overbring.com/ai-benchmarks/2026-10-31-prithivmlmods-groot-19b-a3b-261023-q5-k-m-gguf-rtx-4070-super-12gb-plus-4060-ti-16gb-layer-split-llama-server-cuda/>
> Published: 2026-10-31 21:23:57+00:00

**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](https://overbring.com/benchmark-v5.en). 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:

``` python
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.