Muse Spark 1.2 is a proprietary multimodal reasoning model from Meta Superintelligence Labs, released as a coding-focused update to Muse Spark 1.1. It accepts text, images, video, audio, and PDF documents and returns text, with a context window of roughly one million tokens that allows whole repositories, long documents, and extended agent trajectories to be held in a single request. The model thinks before answering, and the amount of reasoning effort it spends is configurable per request. Alongside its visual and document understanding, it supports structured output and parallel function calling, and it is designed to operate either as a planning agent that delegates work or as a subagent executing tasks in parallel.
Training for version 1.2 scaled up compute on coding tasks and widened the diversity of training environments, concentrating on long-horizon work such as whole-repository generation, large end-to-end projects, and automated research. Part of the training data was self-generated, with Muse Spark 1.1 producing coding environments and instruction-following templates and grading candidate solutions against them. The model was co-trained with the Muse Code terminal agent, incorporating rejection-sampled harness trajectories and that toolset. Meta reports 82.9 percent on Terminal-Bench 2.1, an improvement of 6.7 points over Muse Spark 1.1. Multimodal use cases documented for the family include visual-to-code generation and detailed image and video captioning.
Drag and drop an image here, or click to browse
Captioning will run automatically
—
Usage
Past 30 DaysVision Evals is Roboflow's ground-truth benchmark: every model runs the same real-world samples across six vision tasks, and answers are scored against ground truth.
Evals updated August 6, 2026Pricing updated August 7, 2026
Muse Spark 1.2 averages 80.4% across the six Vision Evals tasks, ranking #5 of 25 models overall.
It places in the top three for OCR and Reasoning.
Its weakest relative showing is Data Extraction, ranking #8 of 25 at 88.7%.
At $0.0071 per sample it is the 16th cheapest of the 25 benchmarked models, and its average inference time of 7.8s per sample makes it the 16th fastest.
Field medians: Object Detection 56.0%, Counting 63.5%, Identification 84.4%, OCR 89.3%, Data Extraction 86.6%, Reasoning 55.6%.
| Task | Score | Field (0 to 100) | Rank | Cost / sample | Speed |
|---|---|---|---|---|---|
| Object Detection | 60.1% | #7 of 25 | $0.0094 | 8.52s | |
| Counting | 74.3% | #5 of 25 | $0.0049 | 6.40s | |
| Identification | 90.6% | #7 of 25 | $0.0038 | 5.34s | |
| OCR | 93.8% | #2 of 25 | $0.0079 | 6.88s | |
| Data Extraction | 88.7% | #8 of 25 | $0.0033 | 4.18s | |
| Reasoning (low) | 74.8% | #3 of 25 | $0.0074 | 10.27s | |
| Reasoning (high) | 76.2% | #4 of 25 | $0.012 | 16.31s |
Overall benchmark score against estimated cost per sample. Upper-left is the sweet spot: high quality at low cost.
25 models on the current benchmark · scores and efficiency pooled across all six tasks at low effort · Muse Spark 1.2 highlighted
Muse Spark 1.2 scores from a single evaluation run · Methodology
View all Vision Evals →Muse Spark 1.2 costs $1.25 per 1M input tokens and $4.25 per 1M output tokens.
Pricing updated Aug 7, 2026
Other models worth comparing for similar use cases.
Muse Spark 1.2 runs as a hosted REST endpoint through Roboflow Workflows. Pick a task, then hand the prompt to your coding agent or copy the code. Forking the workflow into a free Roboflow workspace replaces the your-workspace and YOUR_API_KEY placeholders with your own.
Add the Roboflow MCP server
claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp
Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.
Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).
Fork this workflow to your Roboflow workspace to use it.
Integrate the Roboflow "Muse Spark 1.2" workflow into my app.
- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-muse-spark-1-2-c
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value }, `model_api_key`: my provider key } }.
With the Roboflow MCP connected, call `workflows_get` on "playground-muse-spark-1-2-c" to read the exact input schema and treat it as the source of truth. A live `workflows_run` for this workflow also needs my OpenRouter key (`model_api_key`) passed as a runtime parameter; if you don't have it yet, skip the test run — it will fail with a server error without the provider key, which is expected and not a problem with your code — and rely on the schema. Validate the real run via the REST call once the keys below are set. Without the MCP, use the contract above.
Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
- `OPENROUTER_API_KEY` (sent as `model_api_key`) from https://openrouter.ai/keys — my OpenRouter key
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.
Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.pip install inference-sdkFork this workflow to your Roboflow workspace to use it.
# 1. Import the library
from inference_sdk import InferenceHTTPClient
# 2. Connect to your workflow
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key="YOUR_API_KEY"
)
# 3. Run your workflow on an image
result = client.run_workflow(
workspace_name="your-workspace",
workflow_id="playground-muse-spark-1-2-c",
images={
"image": "YOUR_IMAGE.jpg" # Path to your image file
},
parameters={
"model_api_key": "YOUR_OPENROUTER_API_KEY"
},
use_cache=True # cache workflow definition for 15 minutes
)
# 4. Get your results
print(result)Fork this workflow to your Roboflow workspace to use it.
const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-c', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
api_key: 'YOUR_API_KEY',
inputs: {
"image": {"type": "url", "value": "IMAGE_URL"},
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
})
});
const result = await response.json();
console.log(result);Fork this workflow to your Roboflow workspace to use it.
curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-c' \
--header 'Content-Type: application/json' \
--data '{
"api_key": "YOUR_API_KEY",
"inputs": {
"image": {"type": "url", "value": "IMAGE_URL"},
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
}'Add the Roboflow MCP server
claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp
Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.
Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).
Fork this workflow to your Roboflow workspace to use it.
Integrate the Roboflow "Muse Spark 1.2" workflow into my app.
- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-muse-spark-1-2-op
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value }, `prompt`: text, `model_api_key`: my provider key } }.
With the Roboflow MCP connected, call `workflows_get` on "playground-muse-spark-1-2-op" to read the exact input schema and treat it as the source of truth. A live `workflows_run` for this workflow also needs my OpenRouter key (`model_api_key`) passed as a runtime parameter; if you don't have it yet, skip the test run — it will fail with a server error without the provider key, which is expected and not a problem with your code — and rely on the schema. Validate the real run via the REST call once the keys below are set. Without the MCP, use the contract above.
Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
- `OPENROUTER_API_KEY` (sent as `model_api_key`) from https://openrouter.ai/keys — my OpenRouter key
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.
Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.pip install inference-sdkFork this workflow to your Roboflow workspace to use it.
# 1. Import the library
from inference_sdk import InferenceHTTPClient
# 2. Connect to your workflow
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key="YOUR_API_KEY"
)
# 3. Run your workflow on an image
result = client.run_workflow(
workspace_name="your-workspace",
workflow_id="playground-muse-spark-1-2-op",
images={
"image": "YOUR_IMAGE.jpg" # Path to your image file
},
parameters={
"prompt": "Describe what you see in the image",
"model_api_key": "YOUR_OPENROUTER_API_KEY"
},
use_cache=True # cache workflow definition for 15 minutes
)
# 4. Get your results
print(result)Fork this workflow to your Roboflow workspace to use it.
const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-op', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
api_key: 'YOUR_API_KEY',
inputs: {
"image": {"type": "url", "value": "IMAGE_URL"},
"prompt": "Describe what you see in the image",
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
})
});
const result = await response.json();
console.log(result);Fork this workflow to your Roboflow workspace to use it.
curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-op' \
--header 'Content-Type: application/json' \
--data '{
"api_key": "YOUR_API_KEY",
"inputs": {
"image": {"type": "url", "value": "IMAGE_URL"},
"prompt": "Describe what you see in the image",
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
}'Add the Roboflow MCP server
claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp
Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.
Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).
Fork this workflow to your Roboflow workspace to use it.
Integrate the Roboflow "Muse Spark 1.2" workflow into my app.
- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-muse-spark-1-2-mlc
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value }, `classes`: string array, `model_api_key`: my provider key } }.
With the Roboflow MCP connected, call `workflows_get` on "playground-muse-spark-1-2-mlc" to read the exact input schema and treat it as the source of truth. A live `workflows_run` for this workflow also needs my OpenRouter key (`model_api_key`) passed as a runtime parameter; if you don't have it yet, skip the test run — it will fail with a server error without the provider key, which is expected and not a problem with your code — and rely on the schema. Validate the real run via the REST call once the keys below are set. Without the MCP, use the contract above.
Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
- `OPENROUTER_API_KEY` (sent as `model_api_key`) from https://openrouter.ai/keys — my OpenRouter key
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.
Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.pip install inference-sdkFork this workflow to your Roboflow workspace to use it.
# 1. Import the library
from inference_sdk import InferenceHTTPClient
# 2. Connect to your workflow
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key="YOUR_API_KEY"
)
# 3. Run your workflow on an image
result = client.run_workflow(
workspace_name="your-workspace",
workflow_id="playground-muse-spark-1-2-mlc",
images={
"image": "YOUR_IMAGE.jpg" # Path to your image file
},
parameters={
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
},
use_cache=True # cache workflow definition for 15 minutes
)
# 4. Get your results
print(result)Fork this workflow to your Roboflow workspace to use it.
const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-mlc', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
api_key: 'YOUR_API_KEY',
inputs: {
"image": {"type": "url", "value": "IMAGE_URL"},
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
})
});
const result = await response.json();
console.log(result);Fork this workflow to your Roboflow workspace to use it.
curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-mlc' \
--header 'Content-Type: application/json' \
--data '{
"api_key": "YOUR_API_KEY",
"inputs": {
"image": {"type": "url", "value": "IMAGE_URL"},
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
}'Add the Roboflow MCP server
claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp
Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.
Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).
Fork this workflow to your Roboflow workspace to use it.
Integrate the Roboflow "Muse Spark 1.2" workflow into my app.
- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-muse-spark-1-2-od
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value }, `classes`: string array, `model_api_key`: my provider key } }.
With the Roboflow MCP connected, call `workflows_get` on "playground-muse-spark-1-2-od" to read the exact input schema and treat it as the source of truth. A live `workflows_run` for this workflow also needs my OpenRouter key (`model_api_key`) passed as a runtime parameter; if you don't have it yet, skip the test run — it will fail with a server error without the provider key, which is expected and not a problem with your code — and rely on the schema. Validate the real run via the REST call once the keys below are set. Without the MCP, use the contract above.
Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
- `OPENROUTER_API_KEY` (sent as `model_api_key`) from https://openrouter.ai/keys — my OpenRouter key
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.
Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.pip install inference-sdkFork this workflow to your Roboflow workspace to use it.
# 1. Import the library
from inference_sdk import InferenceHTTPClient
# 2. Connect to your workflow
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key="YOUR_API_KEY"
)
# 3. Run your workflow on an image
result = client.run_workflow(
workspace_name="your-workspace",
workflow_id="playground-muse-spark-1-2-od",
images={
"image": "YOUR_IMAGE.jpg" # Path to your image file
},
parameters={
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
},
use_cache=True # cache workflow definition for 15 minutes
)
# 4. Get your results
print(result)Fork this workflow to your Roboflow workspace to use it.
const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-od', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
api_key: 'YOUR_API_KEY',
inputs: {
"image": {"type": "url", "value": "IMAGE_URL"},
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
})
});
const result = await response.json();
console.log(result);Fork this workflow to your Roboflow workspace to use it.
curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-od' \
--header 'Content-Type: application/json' \
--data '{
"api_key": "YOUR_API_KEY",
"inputs": {
"image": {"type": "url", "value": "IMAGE_URL"},
"classes": ["class1", "class2", "class3"],
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
}'Add the Roboflow MCP server
claude mcp add --transport http roboflow https://mcp.roboflow.com/mcp
Run /mcp and authorize Roboflow in your browser when the OAuth flow opens.
Start a new Claude Code session so the MCP loads, then paste the prompt below (it works the same in any agent).
Fork this workflow to your Roboflow workspace to use it.
Integrate the Roboflow "Muse Spark 1.2" workflow into my app.
- Endpoint: POST https://serverless.roboflow.com/<your-workspace>/workflows/playground-muse-spark-1-2-ocr
- Auth: send my Roboflow API key as `api_key` in the request body, read from the ROBOFLOW_API_KEY env var (never hardcode).
- Body: { "api_key": ..., "inputs": { `image`: { type: "url" | "base64", value }, `model_api_key`: my provider key } }.
With the Roboflow MCP connected, call `workflows_get` on "playground-muse-spark-1-2-ocr" to read the exact input schema and treat it as the source of truth. A live `workflows_run` for this workflow also needs my OpenRouter key (`model_api_key`) passed as a runtime parameter; if you don't have it yet, skip the test run — it will fail with a server error without the provider key, which is expected and not a problem with your code — and rely on the schema. Validate the real run via the REST call once the keys below are set. Without the MCP, use the contract above.
Before running the app, set up these keys so it does not error at runtime:
- `ROBOFLOW_API_KEY` (sent as `api_key`) from https://app.roboflow.com/settings/api
- `OPENROUTER_API_KEY` (sent as `model_api_key`) from https://openrouter.ai/keys — my OpenRouter key
Create a .gitignore'd .env with these variables, using placeholder values for any I haven't given you. Then pause and tell me directly, in your reply: the full path to the .env file, exactly which keys I need to paste in, and the link to get each one. Wait for me to confirm I've added them before you run anything. Do not run the app until I confirm.
Then add the integration to my codebase: match my project's language, framework, and conventions; read every key from environment variables (never hardcode); add basic error handling; and include a small runnable example. If you can't tell what language my project uses, ask me.pip install inference-sdkFork this workflow to your Roboflow workspace to use it.
# 1. Import the library
from inference_sdk import InferenceHTTPClient
# 2. Connect to your workflow
client = InferenceHTTPClient(
api_url="https://serverless.roboflow.com",
api_key="YOUR_API_KEY"
)
# 3. Run your workflow on an image
result = client.run_workflow(
workspace_name="your-workspace",
workflow_id="playground-muse-spark-1-2-ocr",
images={
"image": "YOUR_IMAGE.jpg" # Path to your image file
},
parameters={
"model_api_key": "YOUR_OPENROUTER_API_KEY"
},
use_cache=True # cache workflow definition for 15 minutes
)
# 4. Get your results
print(result)Fork this workflow to your Roboflow workspace to use it.
const response = await fetch('https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-ocr', {
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
api_key: 'YOUR_API_KEY',
inputs: {
"image": {"type": "url", "value": "IMAGE_URL"},
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
})
});
const result = await response.json();
console.log(result);Fork this workflow to your Roboflow workspace to use it.
curl --location 'https://serverless.roboflow.com/your-workspace/workflows/playground-muse-spark-1-2-ocr' \
--header 'Content-Type: application/json' \
--data '{
"api_key": "YOUR_API_KEY",
"inputs": {
"image": {"type": "url", "value": "IMAGE_URL"},
"model_api_key": "YOUR_OPENROUTER_API_KEY"
}
}'License terms and commercial-use guidance for Muse Spark 1.2.
This model is proprietary. The author retains all rights, and use of the model is governed by their specific terms of service or license agreement.
Commercial use depends on the terms set by the model author. Most proprietary commercial models require a paid subscription, API key, or per-call billing. Check the provider’s pricing and terms-of-service for details.
License information is provided as a guide and is not legal advice.
Yes. Muse Spark 1.2 accepts image input and handles OCR, data extraction, object counting, identification, visual reasoning, and object detection. On Roboflow's Vision Evals its strongest task is OCR at 93.8% (#2 of 25). You can test it on your own image in the demo above.
Yes, and it is one of the model's strongest vision skills: its transcriptions match the ground truth 93.8% on average (#2 of 25) on Vision Evals OCR. Pulling specific fields out of documents (data extraction) scores 88.7%.
It's serviceable. On Vision Evals, Muse Spark 1.2 scores 60.1% mAP@50 on object detection (#7 of 25) and 74.3% exact-match accuracy on object counting.
On our benchmark's task mix, Muse Spark 1.2 averages $0.0071 per sample at $1.25 per 1M input and $4.25 per 1M output tokens (#16 of 25 on cost), with an average speed of 7.8s per sample across the benchmark. Actual cost depends on your images and prompts.
On the overall Vision Evals ranking, Muse Spark 1.2 sits #5 of 25 at 80.4%, just behind Gemini 3.6 Flash (83.1%) and just ahead of Muse Spark 1.1 (79.2%). See the full side-by-side: Muse Spark 1.2 vs Gemini 3.6 Flash.