From install to your own private AI agent.

From download to a running AI stack in one click.

Studio carries the entire mimOE runtime inside it: the inference engine, model store, router, and tool gateway, all pre-staged. Nothing to hunt for.

1. Install Runtime. On first run, if no runtime is found, click Install Runtime. Studio provisions the engine, model store, router, the MCP shell gateway (with generated keys), a license, and a starter backend. No terminal, no package manager.
2. Connect. Click Connect and Studio connects to the mimOE runtime on your machine. It's always local: your machine, your data. You land on the Overview, with keys already generated and the gateway enabled, so pulling a model or deploying an agent works immediately.

mimOE Studio · launch

mimOE Studio · Overview

Pull from Hugging Face. Serve it by name.

An agent needs a brain. Go to mimOE → Models, then Pull a model to open the catalog.

1. Browse or search. Curated picks up front; all of Hugging Face behind the search box. Expand a repo to compare quantizations with size and quality side by side.
2. Pick a quantization and pull. A Q4_K_M of a ~30–35B model is a great all-rounder. Progress streams live and pauses and resumes any time, even mid-file, even after a restart. Vision models fetch their projector automatically.
3. Load it. One click moves it onto your GPU; it shows up under Active models with live tok/s.
4. Name it with an alias like qwen. Swap the model later and every app follows, with zero reconfiguration. Clients never learn filenames.

mimOE Studio · Models → Pull a model

Local servers and cloud, behind one router. (Optional: skip if you pulled a model above.)

mimOE ships with its own inference server, and it's genuinely good; for most people it's all you'll ever need. But we're not here to dictate what you run. If you already have inference somewhere (Ollama, vLLM, LM Studio, or a cloud key), bring it. That's what Providers is for: attach what you've already got instead of re-downloading, and it lands behind the same one router as everything else.

• Attach what you already run. Models → Providers → Attach local server, pointed at an OpenAI-compatible endpoint (localhost:11434 for Ollama; vLLM, OVMS, LM Studio too). Its models list live, nothing copied.
• Cloud when you choose it. Register keyed providers (Groq, OpenRouter, OpenAI, NVIDIA, Z.ai) and expose exactly the models you want. Never a silent default.
• Measured, not claimed. Pin a model and Studio probes it on your hardware, giving real tokens/sec next to the name.

ollama pull qwen3.6:35b   # then Attach in Studio and pick it

mimOE Studio · Providers

A raw line to any model. No agent in between.

Before you build an agent, decide if the model is good enough, with nothing in the way.

1. Open mimOE → Try a model, pick a model, and ask. The answer streams live; on thinking models the reasoning streams separately.
2. Read the numbers. Every turn shows tokens/sec measured on your hardware. Comparing two models is just asking both the same question.
3. Nothing is saved. This is scratch paper; history and persistence belong to agents.

mimOE Studio · Try a model

mimOE Studio · Benchmark

A full harness: tools, skills, subagents. Nothing runs without your OK.

1. Deploy in the wizard. Agents → New agent. Name it, pick its model, choose a working directory. Studio deploys the agent as its own microservice with a filesystem sandbox for its file tools and a shell. Two agents never share a workspace.
2. Give it a task. It plans and works in a loop, reading files, editing, running the shell, and calling APIs, streaming every step live.
3. Approve what executes. Risky calls pause: allow once, allow always, or deny. Grants persist per agent under Permissions.

mimOE Studio · New agent

Then just talk to it in Chat. Try “Summarize what this project does,” or “This log is huge, so what are the top 10 errors? Use grep/awk, don't read the whole file.”

mimOE Studio · Agent chat

• Subagents. For work too large for one thread, the agent decomposes, fans out, and collects. Long histories compact automatically.
• Jobs. Save a prompt as a one-click job with parameters, and re-run it without retyping.
• Sessions that survive. Every conversation persists on disk; interrupt mid-tool and resume later, even across restarts.

Skills: teach the workflow once (the differentiator)

A skill is a folder with a single SKILL.md: a short header plus a markdown body. No code, no rebuild. Drop one in and the agent knows the procedure (your report format, a data API, your team's checklist) and applies it when the task matches.

--- name: sec-financials description: Get exact 10-K/10-Q line items from SEC EDGAR's XBRL JSON API. Use this before any web search or PDF download for US financial figures. --- # SEC financial line items via the EDGAR XBRL API 1. Always send a User-Agent header or SEC returns 403. 2. CIK must be 10 digits, zero-padded (1163302 → CIK0001163302). 3. Download to a file, then extract with grep -o.

The description tells the agent when the skill applies, so write it like a trigger. The body is the method.

To add one: open the agent's Skills page (it lists everything installed in .harness/skills/), use + to add, and drop your skill folder in. Copy it, don't symlink (symlinks outside the workspace won't resolve).

mimOE Studio · Agent → Skills

🧩

An ecosystem, ready to drop in. Skills use the open Agent Skills SKILL.md format, the same one Claude Code and OpenClaw use, so the growing library of published skills drops straight into your agent's workspace. And because you choose what to add, the base stays lean.

MCP built in: one governed gateway for every tool your agents touch.

Agents don't wire their own tool servers. Attach an MCP server once, as a remote endpoint or a local command, and the gateway brokers every call, scoped by per-agent keys.

Example: give the agent web search with Tavily.

1. Get a free key at tavily.com.
2. mimOE → MCP Gateway → Add server, as a remote endpoint:

   https://mcp.tavily.com/mcp/?tavilyApiKey=YOUR_KEY

   Copy
3. Issue a scoped key for your agent and grant it this server. Revoke the key and that agent's tools are gone, no redeploy.

The agent now sees tavily__tavily_search. Approve it and ask: “Who is GitLab's current CFO? Cite your source.”

mimOE Studio · MCP Gateway

• One gateway, not N wires. Anything with an MCP server (Jira, databases, browsers, your scripts) becomes an agent tool.
• The shell is itself a gateway server, the same broker every other tool goes through.
• One place to govern. Every tool call crosses one choke point (the same one Trace builds on).

npm i -g @llamaindex/liteparse            # the `lit` CLI
npx skills add run-llama/llamaparse-agent-skills --skill liteparse
# then copy the liteparse skill folder into the agent's .harness/skills/

Engine-ready today; buttons in the app are on the way.

• Squad mode (API only for now): for a heavy read (a 5 MB PDF), the agent delegates the read to a subagent so the parent's context stays tiny. It divides the work itself.
• Workflows (API only for now): the agent plans tasks with dependencies and runs the independent ones in parallel, each in a fresh context, then combines results.
• Vision (engine-ready; no UI yet): load a VLM model and the harness recognizes attached images. There's no image-attach button in the chat composer yet; today images ride the chat API's images parameter.

Every model on your network, in one list.

Run mimOE on more than one machine on the same network and they find each other, with no IPs and no YAML.

1. Each machine (a workstation with a big GPU, your laptop, a lab box) runs mimOE. That's the whole setup.
2. Nodes discover each other automatically over link-local mesh discovery, each with a stable node ID.
3. Discovery (and Models → Nearby) lists what every node is serving right now, queried live, so a node that goes offline disappears.
4. Use them by name. Hit Try, or address a model as {node-id}/{model} from an agent or your own app. The workstation's 35B, usable from your laptop.

mimOE Studio · Discovery

Every mimOE on your network, one click away.

The instance card in the sidebar (top-left in every screen above) is the whole UX. Studio always starts connected to this machine; you switch from inside the app.

1. Click the instance card → Manage Connections.
2. Add by node ID (not IP). Paste it and Resolve, and discovery fills in the address and device name and pins that identity to the profile. Add its management key.
3. Test. The probe verifies it's the machine you pinned, checks the key, and harvests the per-service keys so models, routing, and the Playground work immediately.
4. Connect, safely. Switching commits only on success: a dead target never strands you. If its IP changed overnight, Studio re-resolves the node on the mesh and follows it.
5. While remote, the app wears mimik orange so there's never doubt about whose machine you're driving. One click returns you home.

A receipt for every inference, and the policy layer being built on them.

1. Each request through the router becomes an OpenTelemetry trace: which app asked, which model answered, routing, timing, token counts, and the content itself.
2. Stored on-device. Kept on the machine that served the request. Nothing is shipped anywhere unless you send it to your own collector.
3. Read it as conversations. mimOE → Trace groups spans into conversations, so an agent's run reads like a transcript with metrics. Expand any exchange for the full prompt and response.
4. Governance is coming, honestly. Trace is the shipped evidence layer; policy and audit are being built on exactly these records. Its place is already reserved in the sidebar.

mimOE Studio · Trace

Everything above runs on a local model, on your machine, with your data never leaving it: no cloud API, no per-token bill. And it's not a toy: run through PinchBench, a benchmark built to rank frontier cloud models, on a small local quant, our agent passes across coding, log analysis, CSV, PDF/document work, vision, and web research. Why a small model keeps up:

• A tool never runs / the agent stalls. It's waiting on approval. Approve it in chat or pre-allow under the agent's Permissions.
• lit / a CLI “not found” though it works in your terminal. The shell has its own PATH, so put the binary somewhere already on it (e.g. /usr/local/bin).
• A skill isn't picked up. Confirm it's a real folder at <agent-cwd>/.harness/skills/<name>/SKILL.md (copied, not symlinked) with name/description present.
• “prompt too long” / the model quits early. Its context is smaller than the work needs, so load more context or a bigger model, and lean on bash-aggregation / squad mode for big inputs.
• Web search returns nothing. Check the Tavily server + key are saved in the MCP Gateway and tavily__tavily_search is approved for the agent.
• A nearby / remote node doesn't appear. Both machines must run mimOE on the same network; the list is queried live, so give discovery a moment.