Compose Multiplatform 1.12.0: Hot Reload's MCP Server Lets Coding Agents Watch Their Own Code Run

JetBrains released Compose Multiplatform 1.12.0 on August 26, 2026, and the headline is not another round of API polish. Compose Hot Reload now ships an experimental Model Context Protocol (MCP) server, which means an AI coding agent can connect to a running Compose application, trigger reloads, take screenshots, inspect the semantic tree, simulate clicks and text input, and read application logs. In other words, agents can verify their own edits instead of hoping they are right. UI work has long been the weak spot for coding agents because done is hard to prove automatically; this closes the loop.

1. Why Agents Need to See Their Own Code Run

Backend code can lean on tests and type systems, but UI is stubborn: is the button aligned, does the dialog cover content, is the contrast adequate in dark mode? Static analysis barely sees any of that. Previously an agent could generate code and pray, leaving humans to click through every screen manually. MCP turns the running application into something the agent can read and act on, converting verification from subjective eyeballing into programmable steps. This matters more as agents take on longer UI tasks: without a feedback channel, a ten-step UI change has little chance of being right on the first try, and each wrong guess costs a full human review cycle.

// Compose Multiplatform 1.12.0 WindowState API v2 lets you pick
// the screen and control placement precisely (experimental).
import androidx.compose.ui.unit.DpSize
import androidx.compose.ui.window.v2.WindowBoundsProvider
import androidx.compose.ui.window.v2.WindowPositionProvider
import androidx.compose.ui.window.v2.WindowSizeProvider
import androidx.compose.ui.window.v2.rememberWindowState

val windowState = rememberWindowState(
    initialBoundsProvider = WindowBoundsProvider(
        positionProvider = WindowPositionProvider.CenteredOnScreen,
        sizeProvider = WindowSizeProvider.Fixed(
            DpSize(width = 400.dp, height = 200.dp)
        )
    )
)

2. What the Hot Reload MCP Server Exposes

According to JetBrains, the server lets an agent trigger reloads, take screenshots, inspect the semantic tree, simulate clicks and text input, and read application logs. The semantic tree is the key piece: it is a structured view of components rather than pixel guessing, so an agent can assert that a button exists or that a label is exposed for accessibility. Screenshots and logs cover the two other dimensions: does it look right, and does it run without errors.

// Or let a window size to its content, then expand naturally
// with fillMaxSize() when the user enlarges it.
val flexibleState = rememberWindowState(
    initialBoundsProvider = WindowBoundsProvider(
        positionProvider = WindowPositionProvider.CenteredOnScreen,
        sizeProvider = WindowSizeProvider.Unconstrained
    )
)

// In the composable:
//   Modifier.fillMaxSize()  -- expands when window is resized

3. Wiring It Up and Debugging Tips

MCP speaks standard JSON-RPC, so any agent with MCP support can list and call the tools Hot Reload exposes. When debugging, format the messages with a JSON tool to see the call and result structure clearly. Remember this is experimental: the protocol and tool names may change in later versions, so check the release notes for compatibility notes when you move between 1.12.x patch releases.

// The Hot Reload MCP server speaks standard MCP JSON-RPC, so any
// agent can list the tools it exposes. This is the protocol shape.
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

// Expected tools on Compose Hot Reload (as announced):
//   reload, screenshot, inspect_semantic_tree,
//   click, input_text, read_logs

4. What Else Is New in 1.12.0

Web applications gain automatic font fallback: when rendering hits a character the app fonts do not cover, Compose downloads the matching Noto font subset and recomposes the text, so Japanese, Arabic, Devanagari, and emoji render correctly without bundling fonts by hand. Desktop gets an experimental version 2 of the WindowState and DialogState APIs in androidx.compose.ui.window.v2, with finer control over window and dialog placement and sizing: choose the screen, provide custom positioning and sizing logic, set minimum and maximum sizes, and position dialogs relative to their parent window. See the code samples above.

5. Building an Edit, Reload, Observe, Iterate Loop

To make an agent genuinely reliable, hand it a verifiable UI contract: the button is visible, alignment matches the grid, no new exceptions in the logs, and the semantic tree exposes an accessibility label. After each edit the agent triggers a reload, captures a screenshot, reads the logs, queries the semantic tree, and compares the evidence against the contract, iterating until it passes. The more concrete the contract, the less the autonomous loop drifts.

// The core pattern: edit, reload, observe, iterate. An agent that
// can screenshot and read logs closes its own feedback loop.
async function agentLoop(agent, mcp) {
  await agent.edit('fix the button alignment in Settings');
  await mcp.call('reload', {});              // trigger Hot Reload
  const shot = await mcp.call('screenshot', {});
  const logs = await mcp.call('read_logs', { since: shot.timestamp });
  const tree = await mcp.call('inspect_semantic_tree', { focus: 'Settings' });
  return verifyAgainst({ shot, logs, tree });
}

6. What to Do Today

First, upgrade to Compose Multiplatform 1.12.0 and enable Hot Reload in your development build. Second, connect an MCP-capable coding agent to the Hot Reload server and validate the loop on a small task such as fixing a button alignment. Third, write a UI checklist for your important screens and use it as the agent's verification baseline. Finally, keep reviewing both the MCP interactions and the agent-generated Kotlin: the loop makes agents faster, and review keeps results trustworthy.

// UI-state contract: give the agent something to verify against.
// Screenshot diffs plus the semantic tree beat vibes.
const UI_CHECKLIST = [
  'button is visible on the Settings screen',
  'alignment matches the 8dp grid',
  'no new exceptions in application logs',
  'semantic tree exposes an accessibility label'
];

function verifyAgainst(evidence) {
  const failures = [];
  if (!evidence.tree.includes('SettingsButton')) failures.push('missing node');
  if (evidence.logs.includes('Exception')) failures.push('log exception');
  return failures.length === 0 ? 'PASS' : failures;
}