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

- 1. At a Glance
- 2. Overview
- 3. Specifications
- 4. Performance
- 5. Strengths and Use Cases
- 6. Hardware Requirements
- 7. Can You Run It Locally?
- 8. Our Own Measurements
- 9. Recent Models in the Same Size Class
- 10. How to Get It
- 11. Quantized and Converted Variants
- 12. Related Articles
- 13. What to Read Next
- 14. Sources
- 15. Update History
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
andblocks) 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
- Find models by VRAM (This model runs from the 4GB tier) → Other models that run on a 8GB GPU
- Explore the same model family → plamo-3-nict family overview (1 articles, 1 converted builds)
- Engines that run this model → llama.cpp / Ollama / vLLM
- What Q2_K, Q6_K, Q8_0 mean and where to get this model → GGUF format guide and models / Quantization and model-format glossary
- Learn about the publisher → Preferred Networks (PFN): models, licenses and articles
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.).

