Build with Muse Spark, now available on Meta Model API

The fastest way to feel it: point a coding agent you already use at Model API and hand it an objective.

Most agent CLIs are OpenAI-compatible, so connecting is quick. OpenCode ships with a built-in Meta provider: install it, get a key from the API dashboard, run /connect, filter to Meta, and paste your key. Then pick Muse Spark 1.1.

No Meta option in your CLI yet? Any OpenAI-compatible CLI has a way to add a custom provider: point it at base URL api.meta.ai/v1, add your API key, and set the model to muse-spark-1.1. Those three fields are all it needs; no built-in dropdown required.

Then give it a failing test and let it run:

shell
opencode run -m meta/muse-spark-1.1 \
  "tests/test_pagination.py is failing. Read it and the implementation, fix the bug so the test passes,
  then run: uv run --with pytest pytest tests/test_pagination.py"

Reasoning renders as a dimmed Thought block; tools show as Read, Edit, and bash lines.

On the recipe's sample project, Muse Spark fixes all five planted bugs, averaging 7.6 turns, with pytest as the oracle. (Cookbook: The basic agent loop)

TL;DR: OpenCode has a built-in Meta provider; any other OpenAI-compatible CLI connects by adding a custom provider with the base URL, key, and model. Give the agent an objective check and let it run.

Own the orchestration in code

The same agent loop is a few lines of code. The Responses API holds conversation state for you (previous_response_id) and offers built-in tools such as web_search, so you write the orchestration and let the server carry the thread.

python
import json, os
from openai import OpenAI
​
client = OpenAI(base_url="https://api.meta.ai/v1", api_key=os.environ["MODEL_API_KEY"])
​
def pack_for(conditions: str, days: int) -> dict:
    bag = ["passport", f"{days} days of clothes"]
    if "rain" in conditions.lower(): bag.append("packable rain jacket")
    if "cold" in conditions.lower(): bag.append("warm layers")
    return {"items": bag}
​
tools = [
    {"type": "web_search"},  # built-in, runs server-side
    {"type": "function", "name": "pack_for",
     "description": "Build a packing list from a weather description and trip length.",
     "parameters": {"type": "object",
        "properties": {"conditions": {"type": "string"}, "days": {"type": "integer"}},
        "required": ["conditions", "days"]}},
]
​
resp = client.responses.create(model="muse-spark-1.1", input="I'm in Reykjavik for 3 days this weekend. What should I pack?", tools=tools)
​
while (calls := [i for i in resp.output if i.type == "function_call"]):
    results = [
        {"type": "function_call_output", "call_id": c.call_id,
         "output": json.dumps(pack_for(**json.loads(c.arguments)))}
        for c in calls
    ]
    resp = client.responses.create(model="muse-spark-1.1", input=results, tools=tools, previous_response_id=resp.id)
​
print(resp.output_text)

It's the same read → reason → act → observe cycle the CLI runs for you. (Prefer stateless Chat Completions? You manage the message list yourself; the Cookbook's tool-calling recipe walks through the wire rules.)

TL;DR: the agent loop is a handful of API calls: dispatch each function_call, feed the output back, and let the Responses API carry the thread via previous_response_id.