Everything the display does.
And how to use it.

Claude Code

claude mcp add --transport http screen http://mcpvue.local/mcp

Codex

codex mcp add screen --url http://mcpvue.local/mcp

OpenCode

{
  "mcp": {
    "screen": { "type": "remote", "url": "http://mcpvue.local/mcp",
                "enabled": true, "oauth": false }
  }
}

Any other MCP client works with the Streamable HTTP transport. On Linux, .local names need an mDNS resolver (avahi); otherwise use the IP address from the board's network message. Every board answers as mcpvue.local until you give it its own name in Settings, so give each board its own name to use several at a time.

Tool	What it does
show_message	Shows a message on the display and returns its id (the agent's own, or m1, m2, …).
delete_message	Removes a queued message by its id.
queue_status	How many messages are queued, of 50.
list_messages	The messages with their ids, the start of their text, read or not, and sender; optionally only unread ones, or the first few.
clear_messages	Removes every message (to the archive), when you ask for it.
add_task	Adds a task to the list, or changes one by its id.
list_tasks	The tasks with their ids, text, and due dates; optionally only open ones, or the first few.
get_task	One task from the list by its id, with its whole text.
delete_task	Removes a task, for example once it is done.
add_category	Creates a notes category with a name and an icon, or renames one.
delete_category	Removes a category; one with notes only together with them.
add_note	Writes a note into a category: title, text with colors, bold, and links, an optional colored badge, and its author; with an id it replaces that note.
list_notes	The categories and their notes with ids, badges, authors, and dates, and how many of the 100 notes and 100 categories are used; optionally one category or one badge only. On the D1 the notes on the SD card follow, each saying where it lives.
get_note	One note with its whole text.
delete_note	Removes a note.
report_job	Starts a job (the agent, a title, a short description) or updates it: status, progress in percent, and state (working, question, done, failed). Each report is kept in the job's history.
list_jobs	The jobs with their states, progress, and status; optionally only one state or one agent.
get_job	One job in full, with its history of reports.
delete_job	Removes a job (to the archive); only with a reason.
list_archive	What was deleted and is still kept, newest first: the board's archive, then the older part on its SD card. Only reads; optionally one kind (message, task, note, category, job) and up to 20 at a time, with a cursor for more.
dashboard_help	How to build dashboards: every widget and field, graph axes with dates, tables, the heartbeat, and worked examples (09).
display_info	The board's screen for dashboards: the grid or the RLCD's list, a widget's box for every size, a drawing's coordinates, colours, defaults, and limits; also the firmware version and any update on offer, how many notes and categories are used, and on the D1 the SD card. Agents call it first.
validate_dashboard	Checks a dashboard without storing it: the first error with the allowed range, and warnings.
put_dashboard	Stores a dashboard: a new id adds it, a known one replaces it.
render_dashboard	A dashboard drawn as the board draws it, as a PNG (240 × 240 on the D1, 400 × 300 in black and white on the RLCD) or a 24 × 24 raster of what is drawn where.
delete_dashboard	Removes a dashboard.
push_dashboard_values	Feeds the dashboards: values, histories, table rows, and beats; nothing is written to flash.
list_dashboards	The dashboards with their heartbeat (ok, late, or none); with an id, one whole document, and with values its current values.
move_from_card	On the D1 with an SD card: brings an older message, task, note, job, or archived thing back from the card by its key.

On the D1 with an SD card, list_messages, list_tasks, list_notes, and list_jobs take source: "card" (with cursor for the next page) for the older items on the card, and get_note, add_note, and delete_note take a card note's key. list_archive reads the board's archive and then the card's, newest first.

Every answer also carries the ids and counts as JSON (structuredContent), so an agent need not read them from the text. Ask in plain words: "Show 'Deploy finished' in green on the screen for 30 seconds", or "Put 'Renew the domain' on my task list, due Friday." Agents also add important follow-ups to the list on their own.

The list groups open tasks as Overdue, Today, and Upcoming, then those without a date, then the done ones. The time shows for today's tasks, the day and month (12.10) for others; overdue ones are red, today's amber. The line at the bottom counts what is overdue or due today. In Settings choose the list, cards, or one task at a time.

An open task shows its due badge and date, its headline and text, when it was made, and who added it. Swipe sideways, or press, for the next one. Hold for the quick menu: Done, Delete, Back, Select view. A deleted task goes to the archive.

Due dates are grey before the day, amber on the day, red once the date or time has passed.

Recurring tasks repeat every few hours, every few days, weekly, monthly, or yearly from the date they start. They are never overdue: the lists, the calendar, and the clock show the next time, amber on its day. A monthly task on the 31st falls on the last day of shorter months. A recurring task can have an end date, its last day: after it the task has no next time (it shows "ended" and stays in the list until you tick it or delete it); without one it repeats forever.

Reminders: a task with a date and a time can remind you with a popup and a sound, at its time or a while before (on the web page: Reminder). The popup shows the task with Open task; a press of a button, its cross, a swipe up, or a tap beside it closes it, and it stays until you do. A recurring task reminds before each time; one that comes while the board is off is skipped.

From an agent, add_task takes a headline (up to 64 characters), a body with the same colors as a message, color, font_size, and due as 2026-10-12 or 2026-10-12T18:00; repeat (hours, days, weekly, monthly, yearly) with every for hours and days makes it recurring from due, ends (2026-11-30) gives the series its last day, and remind_before (minutes) adds the popup with a sound. done: true ticks it: it stays in the list and no longer reminds. sender and sender_icon work as for a message. Without an id the display names the task t1, t2, …; with the id of a task it replaces that task.

The list shows each job's state at a glance: an orange ring that fills with its progress, with the percent inside when the agent sends one; a blue question mark while the agent waits for you; a green tick when it is done; a red cross when it failed. Beside it the title, the agent and its latest status, a progress bar, and how long ago the agent last reported; a running job with no update for 30 minutes says "quiet" in amber, since its agent may have stopped. Questions come first, then running jobs, then failed and done ones.

A job, tapped, or opened with the D1's double press or the RLCD's KEY, shows its description and its updates, newest first: the time of each, its state, the status the agent sent, and the progress it had then (the board keeps the last 16). Hold a job for Details, Mark as done, Mark as failed, or Delete, which moves it to the archive; a mark you set shows at the end of its updates.

Keep per agent, on the Jobs web page, chooses how many of its jobs each agent keeps: when an agent's newer jobs push a completed one past that number, it goes to the archive. Running jobs never go by themselves.

On the board, choose Dashboards in the view menu. Each dashboard is a card with its heartbeat mark on the left, its title, its tags, and its icon on the right. The mark is a dot, green while the beats arrive in time and red when one is late or none has come since the board started; or, with Heartbeat countdown (Settings) or the dashboard's own "countdown": true, a ring that empties until the next beat is due and turns red and full when it is late. On the RLCD the ring is drawn in ink, and a late one blinks once a second instead of turning red. A dashboard without a heartbeat has no mark (its title stays in its place). Up to eight tags show as chips in one row above the list: tap one to see only the dashboards with that tag, tap it again for All. When they do not all fit, the row ends in a small down arrow: tap it for a list of All and every tag, and tap one there to choose it (a tap beside the list closes it as it was). The arrow is lit when the chosen tag is one of those not in the row. On the RLCD the chips show but cannot be chosen. Tap a card to open the dashboard; swipe left and right for the next and previous one; swipe up, or tap the back button, to return to the list. Touch and hold a card, or an open dashboard (on the RLCD hold a button), for its menu. Details opens a window about that dashboard: its icon, title, id and tags; the heartbeat with a large countdown ring, the seconds left inside it (or Late, or No beat yet), the limit ("Every 60 s"), when the last beat came, and how many beats and the shortest and longest gap between them since the board started (or "No heartbeat required"); then the updates since boot (the last one, how many, the shortest and longest gap), the widgets by type, and every source with the value it shows, its age and time to live, fresh or stale, its points and the time they reach back, its range, and whether another dashboard reads it too. The window follows the dashboard while it is open and closes by itself if the dashboard is deleted or moves. Drag, hold, or press Next (the D1's button, the RLCD's BOOT) to scroll it a page; the cross, a tap beside it, or Open (the D1's double press, the RLCD's KEY) closes it. Delete dashboard in the same menu asks once ("Delete again to remove …"), and the second choice within five seconds deletes it. A value older than its time to live turns grey; a widget that has had no value yet shows --. On the RLCD each widget is one row: its title and its reading, in the widget's own form. The board keeps up to 10 dashboards of up to 8 widgets each in /dashboards.json; the values themselves stay in memory and are gone after a restart until they are sent again.

The dashboard editor on this site draws a dashboard on the board's grid as you place and set its widgets, and gives you its JSON to paste under Add or replace from JSON on the board's Dashboards page. Everything it writes the board accepts as it is.

A dashboard is one JSON document:

{"v":1,"id":"room","title":"Living room","icon":"home","tags":["house"],"heartbeat":300,
 "widgets":[
  {"id":"temp","type":"metric","cell":[0,0,6,4],"title":"Temperature","unit":"°C","src":"temp",
   "decimals":1,"zones":[[26,"amber"],[29,"red"]]},
  {"id":"hum","type":"metric","cell":[6,0,6,4],"title":"Humidity","unit":"%","src":"hum",
   "style":{"accent":"green"}},
  {"id":"window","type":"status","cell":[0,4,6,1],"title":"Window","src":"window"},
  {"id":"note","type":"text","cell":[0,5,6,2],"title":"Note","src":"room_note"},
  {"id":"time","type":"text","cell":[6,4,6,1],"src":"clock"}]}

A dashboard of daily numbers needs no heartbeat, and one whose feeder runs every 30 seconds can show its countdown:

{"v":1,"id":"daily","title":"Daily numbers","icon":"calendar",
 "widgets":[{"id":"sales","type":"metric","cell":[0,0,6,4],"title":"Sales today","src":"sales"}]}

{"v":1,"id":"host","title":"Host","icon":"server","heartbeat":30,"countdown":true,
 "widgets":[{"id":"load","type":"metric","cell":[0,0,6,4],"title":"Load","src":"load","decimals":2}]}

v is 1. id: 1 to 16 characters of a-z, 0-9, _ and -, starting with a letter or digit. title: up to 24 bytes. icon: one of assistant, robot, terminal, code, build, test, deploy, monitor, server, calendar, mail, home, person, or a picture of your own (see the web page below). tags: up to 4, each 1 to 12 characters of a-z, 0-9 and -; at most 8 different tags on the whole board, 48 bytes together. heartbeat: seconds, 5 to 3600: the mark turns red (on the RLCD the ring blinks) when no beat arrives for that long; 0, null, or no field means no heartbeat: no mark, never late, for dashboards fed now and then, like daily numbers. Dashboards saved by 0.2.16 or earlier, and backups made by it, keep the 60 seconds they had when the field was left out; the board writes the heartbeat out in full from the next save. countdown: true for the countdown ring, false for the dot; left out, the dashboard follows the board's setting Heartbeat countdown (off at first: the dot). It changes only how the heartbeat looks, never whether there is one. widgets: up to 8. One dashboard is at most 7680 bytes of compact JSON; all of them together at most 30 KB. At most 10 custom icons and 40 different sources on the board.

Every widget has an id (as above), a type, a cell [x, y, w, h] on a 12 × 12 grid (cells may not overlap; the grid fills the screen below the header), an optional title (24 bytes), and a src: the name of the value it shows (1 to 16 characters of a-z, 0-9 and _). Widgets that name the same src show the same value, also on different dashboards, so they must use it the same way (a number, the same count of bars, a state, or text). The board takes up to 40 different sources. Colours are names: ink, soft, blue, amber, red, green.

metric: one number, as large as its cell allows, with its unit (8 bytes), decimals (0 to 3), the colour style.accent (blue when left out), and up to two zones [threshold, colour] in rising order that recolour it from that value up. A delta sent with the value shows small at the top right. At least 3 × 2 cells.

{"id":"cpu","type":"metric","cell":[0,0,4,3],"title":"CPU","unit":"%","src":"cpu",
 "decimals":0,"style":{"accent":"blue"},"zones":[[70,"amber"],[90,"red"]]}

gauge: a 270° dial filled from the lower left to the value's place between y.min and y.max (0 and 100 when left out), green below the first zone, then in each zone's colour; with zones, a thin ring outside the dial shows their ranges. The value and its unit sit in the middle; with y the two ends of the scale are written under the dial's ends. Any quantity fits: an engine's speed is "y":{"min":0,"max":8000} with the unit rpm, a car's speed "y":{"min":0,"max":240} with km/h. At least 3 × 3.

{"id":"cores","type":"gauge","cell":[0,0,5,5],"title":"CPU Cores Requests","src":"cores",
 "y":{"min":0,"max":100},"unit":"%","decimals":1,"zones":[[80,"amber"],[90,"red"]]}

{"id":"rpm","type":"gauge","cell":[0,0,6,6],"title":"Engine","src":"rpm","unit":"rpm",
 "y":{"min":0,"max":8000},"zones":[[6000,"amber"],[7000,"red"]]}

bars: up to 6 values, one row each: the label above (or beside, in a short cell), a bar of segments lit up to the value's place between y.min (0 when left out) and y.max (required), green, then amber, then red along its length (at 60 % and 85 % of the scale, or at your zones), and the value on the right in the colour it reached. labels (12 bytes each) set how many bars; without labels give "bars": n. Rows that do not fit show as "+N". At least 3 × 3.

{"id":"usage","type":"bars","cell":[0,0,7,5],"title":"Global CPU Usage","src":"usage",
 "y":{"max":100},"unit":"%","decimals":1,"labels":["Real","Requests","Limits"],
 "zones":[[60,"amber"],[85,"red"]]}

graph: up to three lines over time in one chart. series names each line's src, its label for the legend (12 bytes), and its color (green, amber, blue in order when left out). The left axis has labels at y.ticks (2 to 11) evenly between y.min and y.max, or every y.step from y.min (at most 10 steps; step or ticks, not both; when the range is not a multiple of the step, the top has no line), with the unit and the widget's decimals; without y it follows the values in the window. The bottom axis is time: x.span (60 seconds to five years) shows the last that many seconds up to now (without it, from the oldest point), x.ticks (2 to 6) is how many labels, and x.format how they read: time (14:28), date (29 Oct), month (Oct 26), age (-3 h), or auto (the default: times under two days, dates under 90 days, months beyond). The labels are the board's local time; while its clock is not set they are ages. "fill": true shades the area under each line; "legend": false leaves out the legend. Each source keeps its last 60 points. From 6 × 4 cells with axes and legend; smaller, only the lines. At least 3 × 2.

{"id":"mem","type":"graph","cell":[0,0,12,7],"title":"Memory","unit":"GiB","fill":true,
 "y":{"min":0,"max":23,"ticks":6},
 "series":[{"src":"alloc","label":"Allocatable"},
           {"src":"req","label":"Requested","color":"amber"},
           {"src":"lim","label":"Limit","color":"blue"}]}

A currency rate over seven days, with a line every 0.10 PLN from 3.80 and dates below:

{"id":"usd","type":"graph","cell":[0,0,12,7],"title":"USD in PLN, 7 days","unit":"PLN","decimals":2,
 "fill":true,"y":{"min":3.8,"max":4.2,"step":0.1},"x":{"span":604800,"format":"date"},
 "series":[{"src":"usdpln","label":"USD"}]}

sparkline: one line of the last points of one number, without axes; y and x.span as for a graph. At least 3 × 2.

{"id":"trend","type":"sparkline","cell":[0,0,4,2],"title":"CPU, last minutes","src":"cpu"}

status: a dot and a word: on green, off grey, alert red. In one row the title is the word beside the dot. At least 3 × 1.

{"id":"door","type":"status","cell":[0,0,4,1],"title":"Front door","src":"door"}

text: one line of up to 64 bytes, cut with "…" when longer than its cell. With "src": "clock" it shows the board's own clock. At least 3 × 1.

{"id":"last","type":"text","cell":[0,0,12,2],"title":"Last commit","src":"commit"}

table: up to 8 rows of up to 4 short texts. columns are the header labels (12 bytes each; "" for no header), and their number is the number of columns; rows (1 to 8, 4 when left out) is how many rows a value may have; align has an l or r per column (numbers read best on the right). Rows that do not fit the cell end with "+N more". Two tables on one source need the same columns and rows. At least 4 × 3.

{"id":"rates","type":"table","cell":[0,7,12,5],"title":"Rates","src":"rates",
 "columns":["Pair","Rate","Day"],"rows":6,"align":"lrr"}

primitives: a picture of your own, up to 8 shapes in the cell's own pixels (its top left is 0, 0; whatever lies outside is cut off): rect [x, y, w, h] with r (corner) and fill, line [x0, y0, x1, y1] with w (1 to 12), arc [cx, cy, r] from from to to degrees clockwise from the top with w, text (16 bytes) at [x, y] with size small, text, figure or subhead and align left, center or right; each with a color. At least 1 × 1.

{"id":"logo","type":"primitives","cell":[0,0,3,3],"draw":[
  {"rect":[4,4,98,88],"r":12,"fill":false,"color":"soft"},
  {"arc":[53,48,30],"from":-135,"to":135,"w":6,"color":"green"},
  {"line":[53,48,74,30],"w":3,"color":"ink"},
  {"text":"OK","at":[53,84],"size":"small","align":"center","color":"green"}]}

Values and beats are sent as a list; each entry is either a value for a source or a beat for a dashboard:

{"values":[
  {"src":"temp","v":22.6,"delta":0.4,"ttl":300},
  {"src":"hum","v":47},
  {"src":"window","v":"off"},
  {"src":"room_note","v":"Plants watered on Monday","ttl":3600},
  {"id":"room","beat":true}]}

v is a number for metric, gauge, sparkline and graph, an array of exactly as many numbers as the bars, rows of exactly as many strings as the columns for a table ([["EUR","4.28"],["USD","3.95"]]; [] clears it), on, off or alert for a status, or a string for text. ttl (5 to 3600 seconds, 60 when left out): after that long without a new value the widget turns grey. delta: the change a metric shows beside the number. history: up to 60 numbers, oldest first, that replace a source's points at once (for a graph after a restart); step (1 second to a year, 60 when left out) is the time between them; the last one is now, or at end, a Unix time in seconds (up to five years back; it needs the board's clock); a v in the same entry is added after them, at now. A source keeps 60 points, so send what the graph should show: seven daily closes for a week, twelve monthly averages for a year. For months, use the mean month, "step": 2629746, and date the newest point on the 15th: every point then stays in its own calendar month for up to 12 months (a mean month is not a calendar month, so points dated on the 1st drift into the month before). For exact dates, post each value when it happens instead. A beat {"id":"room","beat":true} keeps that dashboard's mark green for its heartbeat and fills its ring again. A post takes at most 64 entries (more, and nothing is applied). Each entry applies on its own: the answer counts the accepted ones and lists every rejected one with its index and the reason, for example {"ok":true,"accepted":4,"rejected":[{"i":2,"error":"v: on, off or alert"}]}. Values are never written to flash.

{"values":[{"src":"alloc","step":1200,"history":[22,22,22,22,22,22],"v":22},
            {"src":"req","step":1200,"history":[6,6.2,6.1,6.3,6.3,6.4],"v":6.5}]}

{"values":[{"src":"usdpln","step":86400,"ttl":3600,"history":[3.98,3.95,3.97,3.92,3.89,3.91,3.86]},
            {"src":"rates","ttl":3600,"v":[["USD/PLN","3.86","-1.3%"],["EUR/PLN","4.27","+0.2%"]]}]}

With MCP, agents use eight tools: dashboard_help (this whole contract as text, with worked examples for a currency, a car, a server and a home: an agent reads it before building one), display_info, validate_dashboard, put_dashboard (one document, new or replacing the one with its id; its schema states every field and range), render_dashboard, delete_dashboard (an id), push_dashboard_values (the list above), and list_dashboards (all of them with their heartbeat, "beat" ok, late, or none, and the age of the last beat; with an id, that one's whole document, and with "values": true its sources' current values too). A put or delete is answered at once with a change id; it shows on the board once saved, and list_dashboards tells its state: pending, saved, failed, or cancelled.

An agent drawing a dashboard works in four steps. display_info first: the board, its screen and whether it is black and white, the grid (12 × 12 cells of 38 × 34 pixels from 12, 68 on the D1) or the RLCD's list of rows, the size of a widget's box for every cell count, where a drawing's coordinates start (the box's top left, text at its baseline, cut off at the box's edge), the colours, the defaults (no heartbeat, the board's countdown setting), every limit, and which preview scales the board offers; beside them the firmware version and any update on offer, how many notes and categories are used, and on the D1 the SD card. Then validate_dashboard with the document: nothing is stored; the answer says whether the board would take it, gives the first error with the allowed range (for example widgets[0].cell: outside the 12 x 12 grid: x 0 to 11, w 1 to 12 - x (here at most 2)), warns about shapes outside their box, text likely too wide, or widgets that do not fit the RLCD's list, and checks it against the board's other dashboards (unless memory is short or a change is pending; the answer says so). Then put_dashboard. Then render_dashboard with the id (or a document not stored yet) to see the result: a PNG of the dashboard as the board draws it, 240 × 240 on the D1 (half its size) and 400 × 300 in black and white on the RLCD, or with "format": "raster" a 24 × 24 grid of . and # that shows which parts of the screen are drawn on. Fix what looks wrong and put it again. A render takes the board under a second and, for a moment, about 175 KB of memory on the D1 (less on the RLCD); display_info says whether there is enough now. When there is not, the answer says what it needs and what there is.

{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"display_info","arguments":{}}}

{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"validate_dashboard",
 "arguments":{"dashboard":{"v":1,"id":"pc","title":"PC","widgets":[
  {"id":"cpu","type":"metric","cell":[10,0,4,3],"src":"cpu"}]}}}}

{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"render_dashboard","arguments":{"id":"pc"}}}

On your network the MCP address needs no key:

{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"put_dashboard",
 "arguments":{"dashboard":{"v":1,"id":"pc","title":"PC","icon":"monitor","heartbeat":30,
  "widgets":[{"id":"cpu","type":"metric","cell":[0,0,4,3],"title":"CPU","unit":"%","src":"cpu"}]}}}}

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"push_dashboard_values",
 "arguments":{"values":[{"src":"cpu","v":42},{"id":"pc","beat":true}]}}}

From a script on your network, the same through MCP with curl:

curl -s -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"push_dashboard_values","arguments":{"values":[{"src":"cpu","v":42},{"id":"pc","beat":true}]}}}' \
  http://mcpvue.local/mcp

or straight to POST /api/dashboards, which takes {"put": {…}}, {"delete": "id"}, or {"values": […]} and needs the device MCP key (Settings, Remote access) as a bearer token, also through the remote address. A wrong key is refused, never taken for a signed-in browser. GET /api/dashboards lists them; ?id=room returns one; &values=1 adds its current values.

curl -s -H "Authorization: Bearer $MCPVUE_KEY" \
  -d '{"values":[{"src":"cpu","v":42},{"id":"pc","beat":true}]}' \
  http://mcpvue.local/api/dashboards

# Every minute: the CPU load and a beat (crontab -e)
* * * * * curl -s -H "Authorization: Bearer $MCPVUE_KEY" -d "{\"values\":[{\"src\":\"cpu\",\"v\":$(cut -d' ' -f1 /proc/loadavg)},{\"id\":\"pc\",\"beat\":true}]}" http://mcpvue.local/api/dashboards

On the web pages, Dashboards lists them with their heartbeat mark (as on the board), id, icon, tags, heartbeat (or "no heartbeat"), and when the last beat came. Click one to change its title, icon, tags, heartbeat (empty or 0 for none), its mark (the board's setting, a dot, or a countdown ring), and widgets (the widgets as JSON; the board's reason shows if it refuses a change), to delete it, to see each source's current value and its age, to push a test value or a beat, and to see the layout drawn on the board's grid (approximately; the Screen page shows the board itself). Custom icon turns a picture into the board's icon format: it is cropped to a square, scaled to 8 to 32 pixels, and drawn in 16 levels of one colour you choose; Invert swaps light and dark.

After Saver after without a touch or a press (Settings), the board shows its clock; choose Off to keep the last view. Screen off turns the panel off a while after the clock (Never at first on the RLCD). The first touch or press only wakes the screen; a new message wakes it too and opens Messages. With Stay on while a message is unread (on at first) the clock and the screen off wait until every message is read.

The clock shows the time with the seconds in amber, the date, a bar of 60 marks that fills as the seconds pass, and a seconds dial in the corner that glows amber by day and blue by night. Below it the D1 shows the outdoor weather: the temperature, how it feels, humidity, where it is heading in the next hour, and the range of the next 24 hours. The RLCD shows the outdoor and indoor readings side by side, each with its trend. With Next task chosen in Settings your most urgent task shows below the clock instead: overdue first, then due today, then the next due date; tap it, or press a button, to open it.

Badges in the middle of the clock's top line count what waits for you: red for unread messages, blue for tasks overdue or due today. A tap on the clock goes back to Messages or Tasks, whichever you saw last.

The night clock, turned on in Settings, is a calmer clock for the night hours you choose: the time in amber with the short date above it and the seconds below, a ring of 60 dots that fills as the seconds pass, and a pill with the weather, the night's low, and the next sunrise. It fades in and out at the start and end of the night.

Without Wi-Fi a crossed-out Wi-Fi sign shows on the clock.

Messages and tasks go from your computer straight to the board. The board reaches the internet only for the time, a time zone and location lookup by its IP address (ip-api.com), and the weather (Open-Meteo). A board linked for updates also asks mcpvue.com, about once a day and when you check; with remote access on, it keeps its connection to McpVue's relay.

On your network the MCP endpoint has no login: anyone on it can send messages and tasks, unless you turn on Agents on this network need the key too. It rejects requests from web pages of other sites. The web pages are open too until you set a password; on your network the password travels unencrypted, like everything the board serves at http://, so it keeps others on your network out, not someone who can watch the traffic.

Do not forward a port to the board. To reach it from outside, use remote access: there every connection is encrypted with the board's own certificate and decrypted only on the board, the pages need the password, and agents need the board's MCP key.