Build widgets with your AI

You do not have to write a widget by hand. If you use an AI assistant such as Claude, ChatGPT, Copilot in VS Code, Cursor or Claude Code, you can connect it to Tiledash and ask it for the widget you want. It reads Tiledash’s widget guide, looks at your devices, writes the widget, checks it, saves it and shows you the result.

Tiledash does not run an AI of its own and does not charge for one. The assistant is the one you already use, on the plan you already have.

The connection uses MCP, a standard way for an assistant to use a service. Tiledash’s server is at:

https://my.tiledash.app/mcp

Connect your assistant

Every assistant connects the same way: you add the address above, the assistant opens Tiledash so you can sign in, and you allow it. Nothing is pasted in and no key is copied. How signing in works says what the assistant gets.

The same steps, with a copy button, are in the app under your name, Account, then AI assistants, and in the widget editor’s AI panel, with prompts that name the widget you have open.

Claude

In Claude (claude.ai or the Claude app), open Settings → Connectors and choose Add custom connector. On a Team or Enterprise plan an owner adds it first, under Admin settings.
Name it Tiledash and paste the address above.
Choose Connect: Tiledash asks you to sign in with your Homey account and to allow it.
In a chat, ask Claude to help with a widget. It can open a live preview in its browser.

ChatGPT

In ChatGPT, turn on developer mode (in Settings, under Apps and Advanced settings; which plans have it, and where, changes now and then).
Choose Create, name it Tiledash, paste the address above and pick OAuth (leave the client id and secret empty).
Sign in with your Homey account and allow it.

VS Code

Add the server to .vscode/mcp.json in your project (or your user settings).
Start it from the file, or with MCP: List Servers. VS Code opens Tiledash to sign in.
Use it from Copilot Chat in agent mode.

{  "servers": {    "tiledash": {      "type": "http",      "url": "https://my.tiledash.app/mcp"    }  }}

Cursor

Add the server to ~/.cursor/mcp.json (or .cursor/mcp.json in a project).
Cursor shows Tiledash under Settings → MCP with a button to sign in.

{  "mcpServers": {    "tiledash": {      "url": "https://my.tiledash.app/mcp"    }  }}

Claude Code

Run the command below in a terminal.
In Claude Code, run /mcp and choose Tiledash to sign in.

claude mcp add --transport http tiledash https://my.tiledash.app/mcp

The way of working

You talk, the assistant builds, and you watch.

Ask for a widget. Say what you want to see and which device it is for. If you have no device that fits, say so: the assistant can make a test device with the readings it needs.
It saves with a note. Each save goes live at once and carries a short note about what changed. Every save is in the widget’s History, with the note beside it.
It opens the preview link. The assistant gets a link to a page that shows your widget at its true size, with a theme switcher and a choice of screen (desktop, tablet, wall panel or phone) and tile size. The page follows every save, so the assistant looks at the result, spots what is off and saves again. Taps on it are only simulated, unless you let them through (below).
You watch the editor. If the widget is open in the editor, it follows the assistant’s saves. When you have nothing unsaved, a note appears with Undo. When you do have unsaved changes, a banner offers Compare, so nothing you typed is overwritten without you seeing it.

To go back, open the widget’s History and restore an earlier save. A restore is a save too, so you can go forward again.

Partials

The assistant can build partials as well: pieces several widgets share, like a header or a sprinkler that turns while it waters. It declares what each one takes (whether it runs, which zone…) with a type and a default, and checks every state with render_partial before saving, such as the sprinkler turning and standing still. Its preview link draws the partial in a plain tile, with a switch or a choice for each of its parameters, so you can try them too. Widgets you or the assistant write that render it are checked against those parameters when they are saved. It sees the partials you installed from the store as well, at the version you have, and can render them in your widgets by their id; it can’t change them.

Preview links last a day from the last time the assistant asked for one. They stop working when you disconnect the assistant or delete the widget.

Things to ask for

Be plain about what you want and where the numbers come from. You do not need to know the template language.

“Make a widget called Three Phase Usage. It shows the power on each phase of a meter, measure_power.l1, .l2 and .l3, as three bars side by side with the value in watts above each. I have no three-phase meter yet, so make a test device that has those three readings.”
“Look at my devices and make a tile for the living room that shows the temperature big, with the humidity small below it and a colour that turns warm above 24 degrees.”
“Open my Room climate widget and make it work in a one-by-one tile. Keep the settings it has.”
“Make a small widget for the car charger: a battery-style bar for the charge, and the time it will be full. Check it in the dark and the light themes.”
“Start from the built-in light widget and make a version that shows the brightness as a bar.”
“Make a partial sprinkler that shows an icon turning while on is true and standing still when it isn’t, with the zone name beside it. Then use it in a Garden widget for my irrigation valves.”

When the result is close but not right, say what to change. “The numbers are too small from across the room” is enough.

How signing in works and what the assistant can reach

You sign in with your Homey account, the same way you sign in to Tiledash itself. Connecting an assistant opens the Tiledash login, then a screen that names the app and says what it may do. You choose whether to allow it.

Your Homey password and tokens never reach the assistant. It gets a separate Tiledash key, for one purpose: building widgets. That key only works on your own things, and Tiledash checks it on every call.

What a connected assistant can do:

Read and change your own widgets and partials, and see their history
Make and change test devices
Read your devices: their names, kinds, capabilities and current readings
Read the names of your themes

What it cannot do:

Switch your devices or start flows (only you can let a preview’s taps through, for an hour)
Read your history, dashboards, billing or account
See your Homey password or tokens
Reach anyone else’s widgets

The preview link shows one widget or one partial, nothing else of yours, and the taps on it are only simulated: a tap there doesn’t reach your Homey.

To try the buttons for real, turn on Send taps to my Homey for that preview under Account → AI assistants. It lasts an hour and then turns itself off. Only the one device the preview draws can be switched, never a lock, an alarm or a garage door, and only you can turn it on: not the assistant, and not anyone with the link. A preview on a test device has nothing to send to. A link lasts a day from the last time it was handed out.

The tools

These are the tools the assistant has. It picks them itself, so you never need to name one.

Tool	What it does
`get_guide`	Reads the widget authoring guide, by topic.
`get_changelog`	Reads what changed in Tiledash, release by release.
`list_widgets`	Lists your own widgets and Tiledash’s built-in ones.
`get_widget`	Reads a widget: its template, style, settings and saves.
`create_widget`	Makes a new widget, from a built-in, one of yours or empty.
`save_widget`	Saves a change to one of your widgets, live at once.
`restore_widget_save`	Makes an earlier save live again, as a new save.
`check_widget`	Checks a widget without saving it.
`render_widget`	Shows what a widget draws for a device, as markup.
`get_preview_url`	Gives the live preview link to look at a widget or a partial.
`open_in_editor`	Gives the link to a widget in Tiledash’s editor.
`list_partials`	Lists your partials, those you installed and Tiledash’s.
`get_partial`	Reads a partial.
`save_partial`	Makes or changes one of your partials, with its parameters.
`render_partial`	Shows what a partial draws for the values you give it.
`list_devices`	Lists your devices with their capabilities and readings.
`list_test_devices`	Lists your test devices.
`create_test_device`	Makes a test device with the capabilities you choose.
`update_test_device`	Changes a test device’s values or capabilities.
`list_themes`	Lists the themes you can pick.

Working from files

If you would rather work in a folder, with your own editor and an assistant that edits files, a command-line tool is coming. It will sign in the same way and keep a widget as files you can open, change and push back. Until then, the connection above is how an assistant reaches your widgets.

Widgets you build this way are the same as the ones you write: How a widget works explains what is in one.