Step 3.7 Flash – StepFun's Open-Source Flash Model Generation

1. What Is Step 3.7 Flash

Step 3.7 Flash is StepFun's next-generation open-source Flash model for production-grade Agent deployment. Built on a sparse MoE architecture, it maintains high inference speed (up to 400 tokens/s) while reducing activated parameters to 11B. The model is systematically optimized for Agent, coding, search, and multimodal workflows, offering developers a production-grade foundation that balances speed, cost, reliable execution, and complex task completion. Its open-source nature and ecosystem compatibility provide a solid technical base for efficient, reliable AI Agent applications.

Image source: Official article

Technical positioning and domain: Step 3.7 Flash is precisely positioned as a production foundation model for Agents, at the intersection of NLP and multimodal understanding. Rather than pursuing peak performance on a single task, it aims to be the "engine" driving complex, long-horizon, multimodal Agent workflows—addressing high concurrency, low latency, and high reliability in real production environments.

Development background: Developed by StepFun (阶跃星辰). As a leading domestic AI company with deep MoE, multimodal, and Agent expertise, Step 3.7 Flash iterates on prior Flash models to address Agent deployment pain points: unstable execution, high cost, and insufficient speed—reflecting a shift from "model capability" to "system capability."

Core value: Step 3.7 Flash delivers "cost reduction and efficiency" plus "production-grade reliability." With only 11B activated parameters and up to 400 TPS inference speed, it dramatically lowers Agent deployment and operating costs, enabling high-frequency, multi-turn interaction. Stable performance on real-environment benchmarks such as Toolathlon and ClawEval demonstrates reliable complex-task execution in production—solving the industry problem of Agents that "work" but are hard to use.

Technical characteristics: Core features include: (1) extreme cost-performance under sparse MoE—11B activated parameters unlocking near-200B total parameter capability; (2) deep fusion of visual perception, search, and reasoning—actively initiating search for cross-validation on complex visual problems, beyond passive multimodal understanding; (3) optimization for long-horizon Agent trajectories, ensuring coherence and consistency across multi-turn interactions.

2. Key Features

• Native multimodal understanding and execution: Native support for deep understanding of UI interfaces, charts, documents, and images. Beyond recognition, the model converts visual input into structured data, executable code, or concrete actions—e.g., autonomous cropping, zooming, and re-reading—closing the loop from "seeing" to "understanding" to "acting."

• Web and visual search enhancement: Unlike multimodal models relying only on internal knowledge, Step 3.7 Flash strengthens web retrieval and image search. In open or uncertain visual contexts, it actively gathers and cross-compares evidence across text and image modalities, improving accuracy and reliability in fact-checking and verification.

• Highly reliable tool calling and orchestration: In long-horizon, multi-turn Agent workflows, the model stably invokes APIs, browsers, terminals, Office tools, and external systems. A key advantage is optimized task trajectory consistency, reducing "drift" and failure rates in multi-step execution—critical for automated workflows.

• Agent ecosystem compatibility: Optimized and adapted for Claude Code, KiloCode, RooCode, OpenCode, Hermes Agent, OpenClaw, and MCP/Skills protocols. Plug-and-play integration lowers technical barriers and adaptation costs for existing Agent systems.

• Ultra-fast inference: Sparse MoE enables up to 400 tokens/s per request—decisive for high-frequency, multi-turn, low-latency Agent applications such as real-time coding assistants and interactive chatbots.

• Local and cloud dual deployment: High-performance cloud API calls plus workstation-optimized local deployment. GGUF multi-precision edge versions let developers choose deployment based on hardware—from low-end PCs to high-end servers—balancing performance and cost.

3. How to Use

1. Environment requirements and prerequisites:

   • Cloud API: No local hardware required; internet access only. Register at StepFun Open Platform (China: https://platform.stepfun.com; overseas: https://platform.stepfun.ai) and obtain an API Key.
   • Local deployment (full model): High-performance GPU (e.g., NVIDIA A100 or better). Linux (Ubuntu 20.04+) recommended. Python 3.8+, PyTorch, and related frameworks required.
   • Edge deployment (GGUF): Personal workstations or consumer GPUs (e.g., RTX 3090/4090). GGUF-compatible inference frameworks (e.g., llama.cpp) required.

2. Core workflow:

   • Cloud access (recommended for quick start): After obtaining an API Key, send requests via OpenAI-compatible API format. Example with curl: curl https://api.stepfun.com/v1/chat/completions -H "Content-Type: application/json" -H "Authorization: Bearer $API_KEY" -d '{...}'.
   • Open-source deployment (full model): Clone from GitHub (https://github.com/stepfun-ai/Step-3.7-Flash), install dependencies per docs. Download weights from HuggingFace (https://huggingface.co/stepfun-ai/Step-3.7-Flash) or ModelScope; load with Transformers and start inference service.
   • Edge deployment (GGUF): Download GGUF quantized files from HuggingFace (https://huggingface.co/stepfun-ai/Step-3.7-Flash-GGUF). Load with llama.cpp or similar and call via API.

3. Key configuration:

   • API parameters: Configure temperature, max_tokens, top_p, etc. For Agent tasks, set temperature between 0.1–0.3 for execution stability.
   • Local deployment: Choose GGUF quantization (e.g., Q4_K_M, Q5_K_M) based on GPU memory. In llama.cpp, use -ngl N to specify GPU layers, balancing memory and speed.

4. Notes and best practices:

   • Cost optimization: For non-critical simple Agent tasks, prefer GGUF edge versions to save cloud API costs.
   • Agent framework integration: In Kilo Code and similar frameworks, set the model endpoint to Step 3.7 Flash API and configure API Key. Leverage MCP/Skills compatibility for rapid tool chain integration.
   • Error handling: Add retry mechanisms and error logging for long-horizon Agent tasks. Despite high reliability, fault tolerance is still needed in complex scenarios.

4. Pros and Cons

5. Comparison with Similar Tools

Selection advice:

• For Agent developers prioritizing cost-performance and open-source control: Step 3.7 Flash is the top choice. It matches or exceeds Gemini 2.5 Flash on Agent reliability (ClawEval) while offering full open source for deep customization and private deployment, with lower inference cost—ideal for high-frequency, cost-sensitive projects.

• For top multimodal and terminal task execution: If your application heavily depends on complex visual QA (V* benchmark) or extreme terminal operations (Terminal-Bench), Gemini 2.5 Flash may perform better—but you accept closed source, platform dependency, and potential cost. Step 3.7 Flash shows unique value in multimodal-Agent fusion (e.g., visual search verification).

6. Editor's Take

Step 3.7 Flash marks a solid step for open-source large models on the path to production-grade Agents. Its innovation core: it no longer chases single-benchmark "high scores" but systematically resolves three Agent deployment tensions—speed vs. cost, capability vs. reliability, generality vs. ecosystem compatibility. Sparse MoE achieves a "small beats large" cost miracle; 11B activated parameters make "always-on" Agent assistants economically feasible.

Real-environment benchmarks (ClawEval, Toolathlon) prove it is not a "lab model" but a reliable production tool—lower trial cost and faster iteration for developers. It precisely targets the shift from AI "conversation" to "execution."

Target audience: Engineers building complex Agent workflows; startups with strict deployment cost and inference speed requirements; enterprise developers needing private, customizable foundation models; researchers in Agent frameworks and tool chains.

Future potential: As MCP/Skills protocols spread, Step 3.7 Flash's ecosystem advantage will grow. Open source enables community optimization. If it further matches or exceeds closed-source competitors on Terminal-Bench and similar tasks, it could become an Agent development "standard component."

Basis: 0.5 star deducted for hardware barriers (full model) and not leading all benchmarks. Innovation in cost-performance, production reliability, open ecosystem, and multimodal-Agent fusion earns a very high score—it is among the most competitive open-source Agent foundation models today.

7. Application Scenarios

• Coding Agent: Strong on SWE-Bench Pro and Terminal-Bench—stable code generation, debugging, and terminal execution. Integrate into IDE plugins or Kilo Code for semi-automated coding, testing, and deployment.

• Multimodal knowledge work: Automatically understand UI interfaces, charts, and complex documents (PDF, flowcharts) and generate structured reports or operation guides. In product analysis, parse competitor app interfaces and output feature structure and interaction logic for PMs and designers.

• Enterprise process automation: Stably invoke APIs, Office tools (Excel, Word), and internal systems. Embed in workflows for data entry, report generation, and cross-system sync. High reliability ensures stable long-process execution with less manual intervention.

• Visual search and verification: When information is uncertain, actively initiates image search and cross-validation. In e-commerce, compare prices and authenticity from uploaded product photos; in content moderation, cross-compare images and text for higher accuracy.

8. FAQ

Q: How does Step 3.7 Flash differ from standard Transformer models?
A: It uses sparse MoE (Mixture of Experts). Unlike dense models, MoE activates only part of the "expert" networks at inference (11B parameters here) while total parameters reach 196B. This provides large knowledge capacity with inference speed and cost far below equivalent dense models—balancing capability and efficiency.

Q: What does 400 TPS mean in practice?
A: The model generates ~400 tokens per second (~300 English words or ~200 Chinese characters). For users, generation wait time is nearly eliminated—Agent interaction feels near real-time. For developers, more Agent rounds or higher concurrency in the same time window.

Q: Is the model fully open source for commercial use?
A: Yes. Step 3.7 Flash is released under an open license supporting commercial and academic use. You can download, modify, and deploy it for commercial products without copyright concerns. See the GitHub repository for the specific license.

Q: How do I run this model locally?
A: Two main approaches: (1) With a high-end GPU (e.g., A100), download full weights from GitHub or HuggingFace and run with Transformers. (2) For workstations or low-spec devices, download GGUF quantized versions and use llama.cpp or similar—trading slight precision for much lower memory and compute needs.

Q: Is MCP protocol support built in natively?
A: Yes. Step 3.7 Flash was designed with Agent ecosystem compatibility as a core goal, with native-level MCP (Model Context Protocol) optimization. It integrates seamlessly with MCP-compatible Agent frameworks and tool chains without complex adaptation.

9. Project Links

• Official site and blog: https://static.stepfun.com/blog/step-3.7-flash/
• GitHub (code and weights): https://github.com/stepfun-ai/Step-3.7-Flash
• HuggingFace (full model): https://huggingface.co/stepfun-ai/Step-3.7-Flash
• HuggingFace GGUF edge version: https://huggingface.co/stepfun-ai/Step-3.7-Flash-GGUF
• ModelScope (China mirror): https://modelscope.cn/models/stepfun-ai/Step-3.7-Flash