Instructions to use microsoft/Fara1.5-4B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use microsoft/Fara1.5-4B with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="microsoft/Fara1.5-4B")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("microsoft/Fara1.5-4B")
model = AutoModelForMultimodalLM.from_pretrained("microsoft/Fara1.5-4B", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use microsoft/Fara1.5-4B with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "microsoft/Fara1.5-4B"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "microsoft/Fara1.5-4B",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/microsoft/Fara1.5-4B

SGLang

How to use microsoft/Fara1.5-4B with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "microsoft/Fara1.5-4B" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "microsoft/Fara1.5-4B",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "microsoft/Fara1.5-4B" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "microsoft/Fara1.5-4B",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use microsoft/Fara1.5-4B with Docker Model Runner:
```
docker model run hf.co/microsoft/Fara1.5-4B
```

Fara1.5-4B

Fara1.5-4B is a multimodal computer use agent (CUA) for web browsers, from Microsoft Research AI Frontiers. It observes the browser through screenshots and acts on the user's behalf by emitting structured tool calls — click, type, scroll, visit URL, web search, and so on — to complete tasks end-to-end.

The model is vision-only at perception time: it sees the browser through screenshots, not the DOM or accessibility tree. Internal reasoning and trajectory history are tracked as text. Given the latest screenshot and prior actions, it predicts the next action with grounded arguments (e.g., pixel coordinates for a click).

Fara1.5-4B is supervised fine-tuned from Qwen3.5-4B on data generated by FaraGen1.5, our multi-agent pipeline that synthesizes web tasks, executes trajectories to solve them, and verifies the results before training.

It's co-designed with MagenticLite, and that's the recommended deployment for both research and production.

Highlights

End-to-end web task completion. Fills forms, books reservations, applies for jobs, plans trips, runs shopping carts. Not just clicking around — sequencing actions toward a goal.
Vision-only perception. Operates on screenshots alone, no DOM access required. Matches the input modality available to a human user.
Coordinate-grounded actions. Predicts pixel-level click and drag targets directly. No separate grounding model needed.
Critical-points safety design. Trained to stop and ask before personal info entry, payments, submissions, sign-ins, sending messages, or other irreversible actions — even if it could technically continue.
262K context. Long enough for multi-screenshot trajectories with full action history.
On-device viable. 4B parameters means it runs on a single A100/H100/B200 with room for the screenshot history.

Model Details


Developer	Microsoft Research AI Frontiers
Architecture	Multimodal decoder-only LM (image + text → text)
Parameters	4B
Context length	262,144 tokens
Inputs	User goal (text), current screenshot(s), prior agent thoughts and actions
Outputs	Chain-of-thought block followed by a tool-call block (XML-tagged)
Training period	January 2026 – April 2026
Training compute	32 × NVIDIA B200, 2 days
Release date	21 May 2026
License	MIT
Base model	Qwen3.5-4B

Recommended Deployment: MagenticLite

The safest way to run Fara1.5-4B is inside MagenticLite, which provides:

Sandboxing — the browser runs in a Docker container with no access to host files or environment variables
Allow-lists — restrict navigation to a user-specified set of domains
Watch-mode — real-time monitoring of every action with full trace logs
Pause — immediate halt of agent activity at any point

If you integrate Fara1.5-4B directly, you're responsible for these controls. Don't run this model with unrestricted browser access on a machine that has anything sensitive on it.

Quickstart

Requirements

torch >= 2.11.0
transformers >= 5.2.0
vllm >= 0.19.1
A GPU with enough memory for a 4B model in bf16 (A6000, A100, H100, and B200 have been tested)

Serve with vLLM

vllm serve microsoft/Fara1.5-4B \
  --dtype bfloat16 \
  --max-model-len 262144 \
  --limit-mm-per-prompt image=10

System prompt

Fara1.5-4B is trained against a specific system prompt. Use it verbatim for best results:

You are Fara, a computer use agent (CUA) specialized for web browsers. You are developed by Microsoft AI Frontiers. You assist users with completing and automating tasks that require the use of a web browser.

The model was trained in the timeframe of January - April 2026. You can effectively perform tasks even beyond this range by accessing the web browser and using the latest information on the live web. But your knowledge cutoff is limited to early 2026, so you may not be aware of events or developments that occurred after that time, without explicitly browsing and searching for latest information on the web.

This edition of the model was trained using SFT on top of Qwen3.5-4B, using a synthetic data mixture generated and developed by Microsoft AI Frontiers.

A critical point is a situation where we must pause and request information or confirmation from the user before proceeding. There are three types:

Case 1: Missing User Information — The task requires personal information that the user has not provided (e.g., email, phone number, address, payment details). Never fabricate or assume personal information. Fill in only what the user has explicitly provided, then pause and ask for any missing required fields.

Case 2: Underspecified Task — The task description is ambiguous or missing details needed to make a decision at the current step. Pause and ask for clarification.

Case 3: Irreversible Action — We are about to perform an action that cannot be undone (e.g., submitting a form, completing a purchase, sending a message, deleting data). If the user explicitly authorized the action, proceed. Otherwise, stop and ask for confirmation.

Only stop at a critical point if (1) required information is missing, (2) the task is ambiguous, OR (3) an irreversible action lacks explicit user authorization.

The full system prompt, including the complete computer_use tool schema, ships with the model in MagenticLite.

Tool schema

Fara1.5-4B emits actions as <tool_call>...</tool_call> XML blocks containing a JSON object that calls the computer_use function. Supported actions:

Action	Purpose
`left_click`, `right_click`, `double_click`, `triple_click`	Mouse clicks at `(x, y)`
`mouse_move`, `left_click_drag`	Cursor positioning and drag
`type`, `key`	Keyboard input
`scroll`, `hscroll`	Page scrolling
`visit_url`, `history_back`	Browser navigation
`web_search`	Search query
`pause_and_memorize_fact`	Persist a fact across the trajectory
`ask_user_question`	Surface a clarifying question to the user
`wait`	Sleep for N seconds
`terminate`	End the task with a final answer

The screen resolution Fara is most commonly trained with is 1440×900. Match this in your sandbox for the most reliable grounding.

Minimal agent loop

# Pseudocode for a single-step interaction. Use vLLM's OpenAI-compatible
# endpoint and pass the screenshot as an image content part.

screenshot_b64 = capture_browser_screenshot()  # base64 PNG

messages = [
    {"role": "system", "content": FARA_SYSTEM_PROMPT},
    {"role": "user", "content": [
        {"type": "text", "text": "Book a table for 2 at a sushi place in Sunnyvale for Friday 7pm."},
        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{screenshot_b64}"}},
    ]},
]

response = client.chat.completions.create(
    model="microsoft/Fara1.5-4B",
    messages=messages,
    temperature=0.0,
    max_tokens=2048,
)

# Parse the assistant's reply: it will contain chain-of-thought text
# followed by <tool_call>{"name": "computer_use", "arguments": {...}}</tool_call>.
# Execute the action in your sandboxed browser, capture the new screenshot,
# append the assistant turn and a tool/observation turn, and loop until
# the model emits action="terminate". We only keep the most recent 3 screenshots
# in the chat history.

A reference implementation of the full agent loop, including screenshot capture and Docker sandboxing, is in MagenticLite.

Critical Points: Safety by Design

Fara1.5-4B is trained to pause and ask the user at three types of critical points:

Missing user information. If the task needs personal data (name, email, phone, address, payment) the user hasn't provided, fill in what's available and stop to ask for the rest. Never fabricate.
Underspecified tasks. If the goal is ambiguous at the current decision point (e.g., "book me a flight" with no destination), stop and clarify.
Irreversible actions. Submitting forms, completing purchases, sending messages, deleting data — stop unless the user explicitly authorized the action upfront.

Concrete actions Fara is trained to stop on without explicit authorization:

Entering personal information (name, email, phone)
Entering credit card or shipping/billing details
Completing purchases or bookings
Making phone calls
Sending emails
Submitting job applications
Signing into accounts

If the user grants authorization, the model proceeds. The principle is that costly, irreversible actions require a human in the loop.

Evaluation

We evaluate Fara1.5-4B on end-to-end web agent benchmarks. For WebTailBench, we report outcome success.

Model	WebVoyager	Online-Mind2Web	WebTailBench
Fara1.5-4B	80.8	57.3	27.4
Fara1.5-9B	86.6	63.4	32.3
Fara1.5-27B	89.3	72.3	40.2

Training

Approach

Supervised Fine-Tuning on top of Qwen3.5-4B. Training mix is generated by FaraGen1.5, our multi-agent data pipeline, supplemented with curated public datasets for grounding and UI understanding.

Data sources

Synthetic trajectories — Tasks seeded from URLs sampled from a large web index and from open-source seed datasets (e.g., Mind2Web). A multi-agent system attempts each task while recording screenshots, thoughts, and actions. A verifier agent then keeps only successful trajectories.
Grounding — Curated datasets for predicting actions and pixel coordinates from screenshots, with images, text, and bounding boxes.
UI understanding — Visual question answering, captioning, and OCR over web page screenshots collected by the pipeline.
Safety and instruction following — Refusal data covering harmful or unsafe tasks the model should decline.

Scale

Approximately 1 billion text tokens
Less than 1 billion training images
Latest data acquisition: March 20, 2026
Training start: January 2026

The corpus is static. Future updates will ship as separately versioned models with their own model cards.

Intended Use and Limitations

Primary use cases

Automating repetitive web tasks: filling forms, shopping, booking travel, restaurant reservations, information seeking, account workflows. Fara1.5-4B can also serve as a grounding model for other agents that need pixel-accurate action prediction.

Out of scope

Languages other than English (training data is English-only)
High-stakes domains (legal, health, financial advice) where inaccurate actions could cause harm
Allocation decisions affecting legal status, housing, employment, or credit
Unsandboxed deployments with access to sensitive accounts or files
Commercial or real-world production use without additional testing and safeguards

Known limitations

Vision-only perception means the model can be misled by deceptive or low-quality page rendering, prompt injections embedded in page content, or visual ambiguity in UI elements
Multi-step trajectories accumulate error — a misclick early in a sequence can compound
Run-to-run variance on multi-turn tasks is non-trivial; benchmark numbers are averaged over multiple runs
The model can hallucinate page state or misattribute information from earlier screenshots

Responsible AI Considerations

Computer use is a powerful capability. An agent that can click, type, and submit in a real browser can also do those things wrong. We strongly recommend:

Human-in-the-loop monitoring of Fara's actions on the live web with a fast way to halt execution
Sandboxed execution — run Fara in an isolated container with no access to host files, environment variables, or sensitive credentials
Allow-listed or block-listed browsing — restrict the agent's reachable surface to limit exposure to malicious pages
No credential or PII sharing with the agent unless absolutely required and the user has authorized it
Output verification — Fara can hallucinate, misattribute sources, or be misled by deceptive content; verify before acting on its outputs

Safety evaluation

Fara1.5-4B was evaluated via automated red-teaming on Azure. Coverage included groundedness, jailbreak resistance, harmful content (hate, violence, self-harm), and copyright violations. Safety post-training includes both refusal data for malicious tasks and the critical-points framework described above.

Known model risks

Like all language models, Fara1.5-4B can produce unfair, unreliable, or offensive outputs. Specific concerns:

Quality of service varies across English dialects and is worse for non-English content
Representation harms may persist despite safety post-training due to base-model biases
Information reliability — generated content may be inaccurate or outdated
Prompt injection — Fara reads page content, and adversarial content on a page may attempt to redirect its behavior

Developers deploying Fara1.5-4B should apply responsible AI best practices and ensure compliance with applicable laws and regulations. Using safety services like Azure AI Content Safety is recommended.