Wignet
EN
Menu

A screen for what only you care about.

An open display your agents write to over MCP. Tell your agent what you want. Let it do the building.

  • no apps
  • no plugins
  • no widgets
  • no layout editor
Build your Wignet Connect your AI agent

Loading 3D view…

Works with

and any other MCP-compatible agentic platform

What people put on them

One screen. Six prompts.

The morning glanceEvery morning at 06:30, show tomorrow’s swell at Contis and my first meeting of the day.
The interruptIf main goes red, take over the whole screen until it’s green again, and beep once.
The family weekEvery Sunday evening, the family’s week from our shared calendar, one line a day. Redraw whenever something changes.
The wake-upWake me at 07:00, or earlier if my train is cancelled. Something gentle, not a beep.
The one numberOnce a day at 09:00, MRR and the week-over-week move. If it drops, say so plainly.
The recipeFind a recipe for an onion soup and send it to my kitchen.

By design

Four things Wignet does not have.

  1. It doesn’t have a grid system

    No cells, no slots, no zones, no layout editor. The agent gets the whole surface and decides what occupies it, every single refresh. Your 06:30 screen and your 18:00 screen do not have to resemble each other, and usually don’t.

  2. It doesn’t have an app store

    No plugins, no catalogue, no registry, no manifest to write, no review queue, nobody taking a cut. Your agent already knows your calendar, your inbox and your repos. It does not need a weather plugin. It needs somewhere to put things.

  3. It doesn’t have a roadmap

    We keep no feature backlog for what appears on the glass, because that is not our job. The display improves every time your model does. Change your brief on a Sunday afternoon and the wall looks different on Monday morning.

  4. It doesn’t have a screen of its own

    Every screen has a resolution; Wignet has none of its own. The screen declares itself (its size, colours, sound, buttons) and the agent designs for whatever answered: e-paper, colour e-paper, LCD, touch AMOLED or a TV over HDMI. Nothing to port across form factors, because there was never a catalogue to port.

Wignet is a canvas, free for your custom designs.

Setup

Four steps. There is no step five.

  1. Power it up

    The frame opens a Wignet-XXXX access point and serves a config page. Give it your Wi-Fi once, it remembers forever.

  2. Scan the QR code

    It paints a QR code on first boot. Scan it to open the frame’s own link. No account to create: the link is the key.

  3. Add the MCP server

    The frame’s MCP URL goes into Claude, ChatGPT, Hermes, Cursor, or whatever you run. The tool surface is discovered automatically. Each agent, its way in.

  4. Brief your agent

    In plain language, once. From then on the screen is its problem, not yours.

# the whole configuration layer

Every morning at 06:30, show tomorrow’s swell at Contis
and my first meeting of the day.

Between 09:00 and 18:00, show open PRs waiting on my review.
If CI is red on main, drop everything and show that instead,
as large as it will go, and beep once.

After 19:00, go blank.

Platform

Open boards, open firmware, a one page protocol.

get_capabilities()

{
  "screen": {
    "width":           800,
    "height":          480,
    "display_profile": "mono1"
  },
  "speaker": true,
  "alarm":   true
}

Room for the full morning brief, so it shows the full morning brief.

Six surfaces. One protocol. Same MCP server, same frame link. The agent adapts content and interactions to the capabilities the device declares.

Device
ESP32-S3 driving e-paper, monochrome or six-colour, or a small colour LCD or AMOLED. Reference builds are the Elecrow CrowPanel 4.2" and the Waveshare ESP32-S3-ePaper 3.97" at 800 × 480 in monochrome, the Waveshare 7.3" PhotoPainter in Spectra 6 colour, the Waveshare ESP32-S3-LCD-1.54, and the touch-enabled ESP32-S3-Touch-AMOLED-1.8. Many have a speaker and buttons, so an agent can get your attention as well as inform you.
Power
USB or battery, depending on the board. E-paper keeps its image without power and can sleep between refreshes. LCD and AMOLED screens consume power while lit; battery life depends on brightness and use.
Protocol
The device contacts the server to fetch its publications and events. An interactive screen can also send responses from a scene. No inbound ports or local broker to configure.
Rendering
The server composes the frame at the panel’s exact declared geometry and bit depth. Nothing is scaled or cropped on device. Agents push text or an image, or point the frame at a URL it fetches again on every refresh.
Portability
The device contract is a URL that returns a frame at a declared geometry and bit depth. Anything that can fetch bytes and render them qualifies. ESP32 and e-paper are what we build on today, not what the protocol requires.
Licence
Firmware, render server and MCP implementation are open source. Self-host the server if you would rather we never see a frame.

MCP

The entire API your agent needs to learn.

get_state()          → content, baseline, power,
                       last_seen_at, active_event
get_capabilities()   → screen {width, height,
                       display_profile}, alarm

set_message(text)
set_custom_image(image_url)
push_image(image_url | image_base64 | image_file,
           fit, mode, request_id)

get_events() · set_events(events)
push_event(sound, text | image)
cancel_event(id)
set_battery_sync_interval(seconds)
sleep(seconds) · wake()
get/set_orientation · get/set_local_time

That is the whole surface. There is no plugin registry to publish to, no manifest to write, no review queue, no marketplace taking a cut.

An agent reads get_capabilities to learn the canvas it is drawing on, then draws. A 264 × 176 panel on a desk and an 800 × 480 frame on a wall are the same call with different answers, and the agent handles both without being told.

Want a head start? The Wignet agent skill packs the craft on top of the API — check that a change landed, compose for e-paper, send a picture from a sandbox with no network — for Claude and Codex (read it). On ChatGPT, the GPT kit builds the same thing as a GPT. For a Wignet with a speaker, add the alarm, notification and tunes skills.

Future proof

Open is not a licence. It is a durability spec.

It outlives us

The worst thing about a connected object is that it depends on a company staying in business and staying interested. Most ambient displays are one shutdown notice away from being a brick with a nice frame.

Wignet cannot do that to you. The firmware is open, the render server is open and self-hostable, and the device only ever asks a URL for a frame. If we disappear, you change one address and nothing about the object changes. That is the entire migration.

Roughly 400 lines of firmware and an HTTP contract. Fork it, swap the panel, add a sensor, keep the same MCP server in front of it. We kept the device stupid and the contract small on purpose.

It outlives the panel

A Wignet is not a screen. It is a protocol with a screen attached. The device declares what it is, the agent designs for that, and the surface underneath is replaceable.

E-paper is where we started because it suits a mostly static display that should never glow at you. It is not the boundary. Anything that can fetch a frame and render it is a candidate, and the same brief follows you onto it without a single thing to port.

This is the part a plugin catalogue cannot follow. A thousand plugins are a thousand designs pinned to one resolution. Add a second form factor and the catalogue breaks. A canvas does not notice.