StepFun Step 3.7 Flash combines 198B total parameters with about 11B active parameters per token. It also provides a 256K context window, native image and video understanding, tool calling and three reasoning levels. That makes it suited to agent and coding workflows; its memory requirements make it impractical as a local model on normal Macs.
For Mac users, the consequence is straightforward: 8, 16, 24 or 32 GB of unified memory are not realistic for local use. The current model card lists 120 GB of unified memory/VRAM as the minimum and 128 GB as the recommended configuration. For most Mac users, Step 3.7 Flash is an API, cloud or workstation topic.
What is StepFun Step 3.7 Flash?
Step 3.7 Flash is StepFun’s multimodal Flash model for production agent workflows. It combines a large MoE language backbone with a vision encoder and is designed for tasks where a model does not just answer, but plans across many steps, uses tools, analyzes files, edits code and processes visual context.
That makes it less of a simple chatbot model and more of a model for workflows such as:
- coding agents
- terminal and browser agents
- multi-step tool chains
- long document analysis
- UI, screenshot and chart understanding
- search and verification loops
- structured extraction from large files
- agents that need to stay coherent over long task chains
The practical point: Step 3.7 Flash is openly available, but it is not small. A normal MacBook cannot run it meaningfully with a simple ollama run command.
Step 3.7 Flash specifications
| Property | StepFun Step 3.7 Flash |
|---|---|
| Model name | Step 3.7 Flash |
| API model name | step-3.7-flash |
| Architecture | Sparse Mixture-of-Experts |
| Total parameters | 198B |
| Active parameters | about 11B per token |
| Context window | 256K tokens |
| Input | text, image, video |
| Output | text |
| Reasoning levels | low, medium, high |
| Tool calling | yes |
| API format | OpenAI-compatible Chat Completions |
| License | Apache 2.0 |
| Practical on normal Macs | no |
| Official local memory guidance | 120 GB unified memory/VRAM minimum; 128 GB recommended |
Why 198B MoE is not the same as a normal 11B model
MoE means Mixture of Experts. In simple terms, the model contains many expert blocks, but only a subset is activated for each token. That is why Step 3.7 Flash can have 198B total parameters while activating only around 11B parameters per token.
This makes it more efficient than a dense 198B model. But it does not make it equivalent to a small 11B model. The weights still need to be stored, loaded and managed. You also need memory for the KV cache, context window, vision components, operating system, runtime and quantization overhead.
For Mac users, this distinction matters:
- 11B active does not mean it runs like a normal 11B model.
- 198B total parameters means the memory footprint is still huge.
- 256K context means KV-cache and memory use can grow quickly.
- Efficient MoE does not mean MacBook-friendly.
Can Step 3.7 Flash run locally on a Mac?
Yes, but not on a typical consumer MacBook. Although the MoE architecture activates only ~11B of 198B parameters per token, the full expert set still needs to be accessible. The publisher’s GGUF repository provides these approximate weight file sizes, not measured peak memory:
| GGUF asset | Listed size |
|---|---|
| BF16 weights | 394 GB |
| Q8_0 | 209 GB |
| Q4_K_S | 112 GB |
| IQ4_XS | 105 GB |
| Q3_K_M | 94 GB |
| IQ3_XXS | 76 GB |
Vision projector mmproj, additional for images | 4 GB |
Runtime allocations, quantization metadata, KV cache, OS memory, and image/video processing require headroom on top of the weight files. The official llama.cpp setup notes roughly 7 GB runtime overhead, a 120 GB minimum class, and a 128 GB unified-memory recommendation. Do not read those figures as an independently measured promise of full 256K context or comfortable multitasking. Publisher’s llama.cpp guide.
Mac decision: 8–64 GB: cannot hold even the smallest officially listed GGUF weights wholly in memory. Disk offload does not make this a normal interactive experience. 96 GB: possible aggressive-quantization experiments with tight headroom and reduced context. 128 GB or more: a more reasonable starting point for Q4-class runs, provided the specific runtime and context length are tested. The official llama.cpp instructions still describe a StepFun-specific branch; do not claim that every stock Ollama version supports the conversion without testing it. StepFun source and setup.
API routes and U.S. dollar pricing
Verified against the primary model card on October 10, 2026. StepFun operates a global API at https://api.stepfun.ai/v1 and a separate China API at https://api.stepfun.com/v1. Keys from one platform should not be assumed to work on the other. The publisher’s current model card lists these USD token rates per 1 million tokens for the global StepFun API:
| Billing category | Direct list rate |
|---|---|
| Uncached input (cache miss) | $0.20 |
| Cached input (cache hit) | $0.04 |
| Generated output | $1.15 |
A realistic token-budget example: 2 million uncached input tokens, 10 million successful cache-read tokens, and 1 million output tokens cost 2 × $0.20 + 10 × $0.04 + 1 × $1.15 = $1.95. If all 12 million input tokens missed the cache, the same output would bring the bill to $3.55. This is token-fee arithmetic, not a guaranteed hit rate. Failed attempts, tool calls, additional output, and third-party charges can increase the actual cost.
OpenRouter is a separate biller and router. The stepfun/step-3.7-flash model’s provider listings can show different upstream costs, including $0.16 input / $0.92 output, versus the direct StepFun list rate of $0.20/$1.15. Exact provider routing, cache eligibility, and billing must be checked in your account. A promotional or provider-specific rate is not a permanent guaranteed default.
For U.S. developers: Published API rates are in USD, potentially excluding state and local sales taxes or processing fees. A U.S. payment method, U.S. IP address, or English-language prompt does not guarantee U.S.-only processing. For private code or customer data, verify the actual host, contract, retention policy, logging, and any regional controls. Official global model docs.
API example on Mac
StepFun uses an OpenAI-compatible Chat Completions format. On Mac, you can therefore use the OpenAI Python client with StepFun’s base URL and model name.
from openai import OpenAI
import os
client = OpenAI(
api_key=os.environ["STEP_API_KEY"],
base_url=os.environ.get("STEP_BASE_URL", "https://api.stepfun.ai/v1"),
)
completion = client.chat.completions.create(
model="step-3.7-flash",
messages=[
{
"role": "system",
"content": "You are a precise assistant for Mac AI workflows."
},
{
"role": "user",
"content": "Explain why Step 3.7 Flash is difficult to run locally on a normal Mac."
}
],
reasoning_effort="medium",
)
print(completion.choices[0].message.content)Important: API keys do not belong in frontend code, public repositories or static Astro pages. Use environment variables, a backend, a serverless function or secure secret storage.
Reasoning levels and selection
Step 3.7 Flash supports three reasoning levels:
| Level | Best for |
|---|---|
low | simple questions, summaries, rewriting, extraction |
medium | default for normal multi-step tasks |
high | difficult coding, planning, math, deeper analysis |
For everyday questions, high is usually unnecessary. For agent runs, complex code analysis or long document chains, it can make sense. Best practice: start with medium, switch to high only for hard tasks and use low for simple extraction or rewriting.
Coding, agents and tool calling
Step 3.7 Flash is designed for more than chat. StepFun positions it for agent frameworks, tool use and production workflows. That includes:
- terminal tasks
- browser workflows
- file operations
- office-style workflows
- search and verification loops
- multi-file code edits
- tool calling with
toolsandtool_choice
For Mac users, that means the model does not replace local tools like Ollama or LM Studio. It can be a strong cloud complement when local models hit limits in context length, tool stability or complex planning.
Multimodality with image and video
Step 3.7 Flash supports native image and video understanding. This matters for tasks such as:
- analyzing screenshots
- turning UI wireframes into code
- describing charts
- extracting structured data from images
- identifying visual app issues
- using video or frame context in agent workflows
Still, this should not be exaggerated. Multimodality does not mean every complex PDF page or tiny UI detail will be interpreted perfectly. For production workflows, cropping, clear screenshots, readable text and good prompts still matter.
How to read the benchmarks
StepFun publishes strong benchmark signals for agents, coding and multimodal tasks. Examples include:
| Area | Benchmark | Step 3.7 Flash |
|---|---|---|
| Agentic coding | SWE-Bench Pro | 56.3 |
| Terminal/agent | Terminal-Bench 2.1 | 59.5 |
| Tool use | Toolathlon | 49.5 |
| Agent robustness | ClawEval-1.1 | 67.1 |
| Multimodal | SimpleVQA with Tool | 79.2 |
| Multimodal | V* with Python | 95.3 |
These values are not a guarantee for your own website, repository or Mac workflow. Benchmarks depend on harness, tooling, prompting, model version, reasoning level, context, temperature and evaluation method.
For a Mac-specific assessment, separate vendor results from your own workload:
Step 3.7 Flash targets agent, coding and multimodal tool workflows; practical tests are still necessary.
Step 3.7 Flash vs local Mac models
Step 3.7 Flash and local Mac models solve different problems.
| Criterion | Step 3.7 Flash | Local Mac models |
|---|---|---|
| Privacy | cloud processing when using API | can stay fully local |
| Context | 256K tokens | depends on model, RAM and runtime |
| Model size | 198B MoE | usually 3B to 32B on normal Macs |
| Cost | API cost or expensive hardware | no token cost, but hardware/time |
| Offline use | only with local high-memory setup | yes |
| Agent performance | key target area | depends on model |
| Setup effort | API easy, local hard | small models easy |
| Normal Mac fit | API yes, local no | yes |
For confidential files, private notes and offline work, local models with Ollama, LM Studio, MLX or llama.cpp remain the better choice. For large agent runs, long contexts, complex tool chains and multimodal API workflows, Step 3.7 Flash can be a strong complement.
Practical decision: 10 tasks that reveal model quality
A larger parameter count is not proof of better coding. Run Step 3.7 Flash against your existing local Mac model on the same tasks and tool definitions. Do not paste private repository secrets into a hosted prompt.
- Choose three bug fixes with automated tests, three structured extractions, two screenshot-based UI tasks, and two multi-step tool workflows.
- Keep prompt, tool schemas and input files constant. Record
reasoning_effort, model/provider ID, context size and temperature. A different upstream on OpenRouter changes the comparison. - Score each answer by passing tests, correct JSON, reviewable diffs or verified sources, not by confident prose. Count incomplete tool calls and retries.
- Log elapsed time, billed input/cache/output tokens, retries and cost per successful task. A low advertised token price is not automatically a low cost per job.
This is an editorial test plan, not a benchmark run on ai-on-mac.com. StepFun’s published SWE-Bench Pro (56.3) and ClawEval-1.1 (67.1) are vendor figures, not Mac performance measurements. Official model release.
| Your Mac and task | Practical first option |
|---|---|
| 8–64 GB, ordinary coding/chat | Smaller local model via Ollama, LM Studio or MLX |
| Large cloud coding task with many tool calls | Compare Step 3.7 Flash Global API with the local baseline |
| Private and offline work | Locally hosted model sized for available unified memory |
| At least 128 GB, experimental deployment | Follow StepFun’s Metal llama.cpp branch and measure real memory |
Memory matters more than “11B active”. The smallest published GGUF is 76 GB, the Q4_K_S weight file is 112 GB, and the publisher recommends 128 GB unified memory with around 7 GB runtime overhead. 96 GB might allow an aggressively quantized short-context experiment, not a guaranteed usable configuration. GGUF repository. The official llama.cpp setup still uses a StepFun-specific step3.7 branch: generic Hugging Face Ollama snippets do not prove compatibility with every installed release.
For a real project, verify retention, logging and processing location with your chosen provider. U.S. billing does not establish U.S.-only inference.
When another model is a better fit
Use a smaller model when your local baseline already passes the test suite, when offline operation or strict confidentiality is required, or when you do not have the memory budget for a 198B MoE. Advertised 256K context is not evidence that an arbitrary agent runtime can submit or handle the full window reliably.
FAQ
Does Step 3.7 Flash run on a MacBook Air?
Not realistically as a local model. For normal MacBook Air configurations, the model is far too large. Use smaller local models or the API instead.
Is 32 GB of unified memory enough?
Not for practical local use. 32 GB is useful for many 7B, 8B, 14B or sometimes 27B models, but not for a 198B MoE model of this class.
Why are 11B active parameters not enough for normal Macs?
Because the total weights are still huge. MoE activates only part of the model per token, but model weights, quantization, KV cache and runtime still need a realistic memory budget.
Is Step 3.7 Flash open source?
More precisely: Step 3.7 Flash is an open-weight model under Apache 2.0. The weights are openly available, but the model is still not an easy local Mac model because of its size.
What does the API cost?
StepFun lists $0.04 per 1M input tokens for cache hits, $0.20 per 1M input tokens for cache misses and $1.15 per 1M output tokens.
Is Step 3.7 Flash better than local Qwen, Gemma or Llama models?
Not universally. It is larger and more focused on agents, tool use and multimodality. Local models are more private, cheaper to run once installed and more realistic on normal Macs.
Step 3.7 Flash on Mac: API rather than local inference
StepFun Step 3.7 Flash is a large open MoE model for agents, coding, tool use and multimodal workflows. Normal Macs are not its target hardware for local inference.
Its relevant properties are the combination of 198B total parameters, about 11B active parameters per token, 256K context, reasoning levels, tool calling and API availability. The limit is equally clear: local experiments require a lot of unified memory.
For Mac use, the practical split is: local models for private offline work, Step 3.7 Flash for large agent and cloud workflows, with local experiments viable only on top-tier unified memory configurations.
How 198B MoE and API costs fit together is covered in the unified memory guide and the DeepSeek V4.1 Flash guide.
Sources and status
Reviewed October 10, 2026 against StepFun’s official model documentation, GGUF files and reference implementation. No on-device Mac benchmarks or paid API calls were executed for this technical review.
Frequently Asked Questions
Does Step 3.7 Flash run on a MacBook Air?
Not realistically as a local model. For normal MacBook Air configurations, the model is far too large. Use smaller local models or the API instead.
Is 32 GB of unified memory enough?
Not for practical local use. 32 GB is useful for many 7B, 8B, 14B or sometimes 27B models, but not for a 198B MoE model of this class.
Why are 11B active parameters not enough for normal Macs?
Because the total weights are still huge. MoE activates only part of the model per token, but model weights, quantization, KV cache and runtime still need a realistic memory budget.
Is Step 3.7 Flash open source?
More precisely: Step 3.7 Flash is an open-weight model under Apache 2.0. The weights are openly available, but the model is still not an easy local Mac model because of its size.
What does the API cost?
As of October 10, 2026, the direct StepFun Global API card lists $0.20 uncached input, $0.04 cached input and $1.15 output per million tokens. OpenRouter has separate provider-specific prices.
Is Step 3.7 Flash better than local Qwen, Gemma or Llama models?
Not universally. It is larger and more focused on agents, tool use and multimodality. Local models are more private, cheaper to run once installed and more realistic on normal Macs.