plamo-3-8b-fin-instruct Text Generation Model: 4GB+ VRAM, GGUF Builds

plamo-3-8b-fin-instruct Text Generation Model: 4GB+ VRAM, GGUF Builds

At a Glance

Item Value
Repository pfnet/plamo-3-8b-fin-instruct
Family guide plamo-3-nict guide (1 articles)
Publisher guide Preferred Networks (PFN): models and licenses
Published 2026-11-08
License plamo-community-license
Formats safetensors
Source type Primary source (the publisher itself)

Values determined by this site’s code when the information was collected. Dates are JST.

Overview

On November 8, 2026, Preferred Networks, Inc. (PFN) released “PLaMo-3-8B-Fin-Instruct", a Japanese language model specialized for the financial domain, on Hugging Face. This model is an instruction-tuned model developed by performing continued pre-training on the base model “pfnet/plamo-3-nict-8b-base" using a financial corpus, followed by supervised fine-tuning (SFT) and direct preference optimization (DPO).

This model is designed as a chat model that performs reasoning (thought processes) in Japanese before outputting answers, allowing users to verify the thought process behind the response. It also features the ability to execute Function calling (tool use) by passing OpenAI-format tool definitions. Part of the training process utilized “MN-Core 2", a deep learning accelerator independently developed by PFN.

Specifications

The specifications listed on the official model card are as follows:

  • Parameters: 8B
  • Architecture: Causal decoder-only (Plamo3ForCausalLM)
  • Context length: 262,144 tokens (Maximum length of the base model. Continued pre-training using the financial corpus used sequences of up to 32,768 tokens)
  • Supported languages: Japanese

Performance

Quantitative benchmark scores and numerical comparison tables with other models are not published in the model card for this model or the base model “pfnet/plamo-3-nict-8b-base". Therefore, performance comparisons with other models based on objective measurement figures cannot be made.

On the other hand, the “Bias, Risks, and Limitations" section of the model card mentions qualitative characteristics and precautions by the publisher.

First, it is explained that this model is a specialized model additionally trained on a dataset in the financial domain and is not a general-purpose assistant model. Therefore, when using it for tasks outside the financial domain, evaluations tailored to the target task must be conducted in advance.

Additionally, because the parameter count is at the 8B scale, it holds less factual knowledge compared to models with larger parameters, and tends to be more prone to hallucinations where it confidently outputs factually incorrect information. Therefore, outputs regarding facts and figures must be verified by checking against reliable sources, and operations involving human intervention (human in the loop) are required when making important decisions.

Furthermore, the operational accuracy of the Function calling feature is guided to depend on the tools and tasks used. It is strongly recommended to verify accuracy in the intended use case before deploying to a real environment, perform verification against the schema before execution, and make human confirmation mandatory prior to actions that affect the real world, such as placing orders or transferring funds.

In addition, it is explicitly stated that the output of this model does not constitute professional advice regarding legal, financial, tax, or investment matters, and must not be presented as such to end users. Use in applications that make investment decisions on behalf of users is also prohibited.

Strengths and Use Cases

PLaMo-3-8B-Fin-Instruct specializes in Japanese dialogue and tasks within the financial domain. By applying continued pre-training on a financial corpus, supervised fine-tuning (SFT), and direct preference optimization (DPO) to the base model “pfnet/plamo-3-nict-8b-base", it is tuned to handle financial contexts and specialized expressions.

Specifically, the features it excels at and its main uses are as follows:

  • Output of thought processes in Japanese: When generating answers, it first writes the thought process in Japanese (enclosed in and blocks) before outputting the final answer. It is possible to separate and display or utilize the thought blocks and answers on the user interface side.
  • Function calling (tool use): By passing OpenAI-format function definitions, it can output code to call external tools or APIs. For example, if a function to retrieve stock prices from a ticker code is defined, the model outputs structured data containing the necessary arguments in JSON format when it determines tool use is appropriate.

Main anticipated use cases include Q&A related to the financial field, analysis and editing support for specialized documents, and financial information search processing linked with external systems. However, operations must be conducted with the awareness that this model is specialized in the financial domain rather than being a general-purpose assistant, and that output results must not be treated as professional legal, financial, or investment advice.

Hardware Requirements

Estimated requirements (calculated by Local Model Watch) — 8.5B parameters

Your VRAM Quantization File size Est. memory needed
4GB (laptop iGPU / phone class) Q2_K 3.2GB 3.9GB
8GB (RTX 4060 / 3060 Ti, etc.) Q6_K 6.5GB 7.8GB
12GB (RTX 4070 / 3060 12GB, etc.) Q8_0 8.4GB 10.1GB
24GB (RTX 4090 / 3090, etc.) F16 15.9GB 19.1GB

Inference engine support (architecture name matched against each project’s own model registry in its source code, checked 2026-11-17): llama.cpp: registered, vLLM: registered, MLX (mlx-lm): registered.

Memory estimates add a 20% runtime overhead (KV cache, etc.) to the actual size of the distributed files. Actual usage varies with context length, batch size and inference engine. These figures are computed by this site from file sizes, not published by the model’s authors. File sizes are measured from the converted build mradermacher/plamo-3-8b-fin-instruct-GGUF. Compare with other models in our VRAM quick reference. What the quantization names mean: glossary.

Can You Run It Locally?

Runs in Ollama, LM Studio and llama.cpp via a converted build.

The publisher ships safetensors, but mradermacher/plamo-3-8b-fin-instruct-GGUF provides a GGUF build you can use.

License — plamo-community-license: A custom license from the publisher. Check the original terms directly, including whether commercial use is permitted.

Compression: the Q2_K build measures 3.22 bits per weight — about 20% the size of the original 16-bit weights, calculated by this site from the actual file sizes.

Compiled by this site’s code from the published formats, converted builds we have found, and each engine’s own model registry. “Not found" means we have not seen such a build, not that none exists. License summaries are not legal advice — check the publisher’s original terms before relying on them.

Our Own Measurements

Measurements We Did Not Take

We have not confirmed that this site meets the commercial-use terms of this model’s license (plamo-community-license). Because this site carries advertising, we did not run the model (no CPU run, answers, quantization comparison, conversion or generation).

Recent Models in the Same Size Class

Models with 4–15B parameters that Local Model Watch covered recently, listed by code from our article log for comparison. VRAM tiers are this site’s estimates; licenses are as stated on the model cards.

→ Scroll horizontally to see all columns

Model Parameters Smallest VRAM tier License Our article
microsoft/UserRepGen-4B 4.5B 4GB mit UserRepGen-4B Text Generation Model: 4GB+ VRAM, GGUF Builds (2026-11-17)
IFM/Jais-3-7B-GGUF 9.0B 8GB apache-2.0 Jais-3-7B-GGUF Arabic and English 7B Reasoning Model: 8GB+ VRAM (2026-11-17)
IFM/Jais-3-3.7B-GGUF 5.1B 4GB apache-2.0 Jais-3-3.7B-GGUF 512K Context Language Model: 4GB+ VRAM (2026-11-17)
ibm-granite/granite-switch-4.1-8b 8.8B 24GB apache-2.0 IBM Releases Granite Switch 4.1: Modular LLMs with aLoRA and Speech (2026-11-17)
ggml-org/NVIDIA-Nemotron-3.5-Bolt-E4B-GGUF 8.0B 12GB apache-2.0 NVIDIA-Nemotron-3.5-Bolt-E4B-GGUF Text Generation Model: 12GB+ VRAM (2026-11-17)

How to Get It

PLaMo-3-8B-Fin-Instruct is available in safetensors format on the Hugging Face repository (pfnet/plamo-3-8b-fin-instruct). The “PLaMo community license" applies to its license.

The Hugging Face transformers library is used to load and run inference on the model. The operating environment and library versions tested and verified in the official model card are as follows:

  • Python: 3.12
  • PyTorch: 2.9.0
  • Transformers: 5.20.2
  • Accelerate: 1.15.0
  • NumPy: 2.5.4
  • Numba: 0.68.0

An example of basic loading and running inference from a Python environment is as follows. Because custom implementation code is executed, specifying trust_remote_code=True is required.

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "pfnet/plamo-3-8b-fin-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name, trust_remote_code=True, dtype=torch.bfloat16, device_map="auto"
)

messages = [
    {"role": "user", "content": "PERとは何ですか?一文で答えて。"},
]
inputs = tokenizer.apply_chat_template(
    messages, add_generation_prompt=True, return_dict=True, return_tensors="pt"
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

When using Function calling, pass OpenAI-format tool definitions (a list of dictionaries) to the tools argument when executing apply_chat_template. When the model selects a tool call, it outputs the call request in a specific format (enclosed by <|plamo:begin_tool_requests:plamo|> or similar). The application side parses and executes this, adds the result to the conversation history as a role: "tool" message, and then feeds it back into the model to generate the subsequent answer. Note that in order to correctly process tool call results within the dialogue history, the tools argument must be passed during each turn’s template call.

Quantized and Converted Variants

→ Scroll horizontally to see all columns

Added Publisher Format Repository Smallest VRAM tier (build, est. memory)
2026-11-17 mradermacher GGUF mradermacher/plamo-3-8b-fin-instruct-GGUF Q2_K 3.9GB (fits in 4GB VRAM)

File sizes of each build:

  • Available builds in mradermacher/plamo-3-8b-fin-instruct-GGUF: Q2_K 3.2GB / Q3_K_S 3.6GB / Q3_K_M 4.0GB / Q3_K_L 4.4GB / IQ4_XS 4.5GB / Q4_K_S 4.6GB / Q4_K_M 4.9GB / Q5_K_S 5.5GB / Q5_K_M 5.7GB / Q6_K 6.5GB / Q8_0 8.4GB / F16 15.9GB

In addition, 1 converted build(s) from other uploaders exist on Hugging Face; this site lists only builds from the model’s publisher or established quantization maintainers.

This section is appended automatically by Local Model Watch when a converted build of this model appears after publication. Memory figures are estimated from the size of the distributed files. What the quantization names mean: glossary.

Related Articles

What to Read Next

Sources

Update History

  • 2026-11-17: Added converted builds to “Quantized and Converted Variants”: mradermacher/plamo-3-8b-fin-instruct-GGUF
  • 2026-11-17: Updated the hardware requirements table with the actual file sizes of mradermacher/plamo-3-8b-fin-instruct-GGUF.
  • 2026-11-17: Changed the title to show what the article covers (VRAM requirements, file list, etc.).