Corral for Alexa+

The kitchen Echo Show answering "What's going on tonight?" on the Today tab
One tap to the Animals tab: nine collars on the property map
The Echo speaking up on its own: "Heads up: Hunter just left the fence"
The same Today screen as Nick, Eli and Jon, side by side: the rules follow the person
Kids ask, parents decide: Eli's sleepover waiting on Nick's approvals screen
"It's going down to 12 tonight": the heaters on after one yes
The Automations tab, with freeze protection on
Jon's hay order from the barn, waiting for Nick's tap on the kitchen's screen
The morning briefing, opening on what happened since last night
Our real greenhouse misters spraying, switched by this server
The open-source Alexa+ simulator and its readiness report
The same server in Claude, drawing the Today screen in the chat
How it fits together

Inspiration

Corral is the household platform I built for my family and my small ranch. It's the shared calendar, the chores and who did them, the grocery list, where the kids are, points toward allowance, the hay and feed in the barn, and the heaters and water on the ranch. It lives on wall tablets and phones. But the place a family actually talks out loud is the kitchen, and the device there is an Echo. Alexa could set a timer; it couldn't answer "who's picking up Eli?", "did anyone give the dog her pill?" or "is it going to freeze tonight, and are the animals in?" I wanted Alexa+ to know my family's day and run the place, without giving up the rules that make a family system safe: private appointments stay private, kids' changes wait for a parent, and the farm hand only sees the ranch.

This isn't a mockup. Corral has run my family and the ranch every day since September 28, at corral.narralogy.ai, on a hub in the kitchen, everyone's phones and a board in the barn. The Alexa+ server is deployed beside it and linked to it with real account linking, so every request in the demo is one my family, the kids or the farm hand actually makes. The public demo runs on a made-up household shaped like mine, so judges can try all of it without my family's data.

What it does

Corral for Alexa+ is a self-hosted MCP server that gives Alexa+ the household and the ranch, with touch screens for the Echo Show.

Ask about the day, see it at a glance. "What's going on tonight?" opens the home screen: Today (the calendar with what's on now and next, chores to tap off, who's where), and tabs for the Ranch, the Animals and the Automations, so a tap moves between them with no round trip to the assistant.
Every voice is a person. Alexa+ knows who's talking, and the family's rules follow the person. Eli asks for a sleepover and it waits for a parent; Jak asks for the coop's heat lamp and hears that only Nick, Holly or Jon can switch it; Nick says "Anything waiting for me?" and approves with a tap. A private appointment is just "that time's taken." The farm hand hears about the ranch, not the family.
It speaks up on its own. Corral watches the dogs' collars. When Hunter slips past the fence, the Echo chimes, its light turns amber and it says "Heads up: Hunter just left the fence, about 360 feet out to the northeast, near the Woods." An automation that runs is said the same way, and the assistant is told, so a follow-up knows who. MCP can't push to a device, so the simulated Echo asks a screen-only tool every few seconds; the Alexa team confirmed that real add-ons get a way to send proactive notifications.
One sentence, five systems. "It's going down to 12 tonight. Get the place ready." reads the forecast, every heater, the dogs' GPS collars, who's home and the supplies in one turn, then one confirmation turns on the tank heaters and coop lamp and gives whoever's home a task to bring in the two dogs outside the fence. When Holly says "I brought Hunter and Pepper in," the task is checked off as hers.
It orders what runs low, within the family's rules. In the barn, Jon says "We're down to four bales of hay." Alexa records it (about two days' worth, until Wednesday) and offers 20 bales for $290. Jon is the farm hand and can't spend money, so the order waits for a parent: the kitchen Echo Show's Today screen shows "Jon asks" with Approve, and Nick's tap places it, arriving Thursday. A parent's own order goes straight through unless it's over the household's spending limit.
The next morning remembers the night. "Good morning" opens a briefing carousel on what happened since last night (the heaters left on, the hay ordered, the dogs brought in, freeze protection set), then today, the weather, chores, supplies and the animals. A new conversation, the same household.
Then it happens on its own. "Do all of that whenever it's going to freeze" turns on an automation: at 5 PM, when tonight's low is 25°F or colder, the heaters come on by themselves. Misting and watering run on schedules the same way, through the same device limits as a voice request.
Real hardware. "Turn on the misters for 30 seconds" goes through a connector to my ESP32 greenhouse controller on the ranch's network. In the video (filmed October 20), Alexa asks first, the relay clicks on, the real misters spray over the kale, the Ranch tab counts the run down, and the controller shuts the valve after 30 seconds. The hosted demo uses a simulated controller with the same limits.
One household on every device, kept across sessions. The kitchen and barn Echo Shows share one household: check a chore off on one, by voice or touch, and the other's screen shows it within seconds. The household lives in a Durable Object, so it survives restarts and deploys.
Screen or no screen. On an Echo Dot the same tools answer in words: the simulator tells the model there's no screen, so "What's going on tonight?" becomes three short spoken sentences, and the Dot still speaks up when a dog gets out.
One server, every assistant. I added the same MCP URL to Claude as a custom connector and it worked as-is: Claude called show_today and rendered the tabbed screen in the chat. An Agent Skill teaches any assistant how to be a good household helper.

Since the Alexa+ developer tools are partner-only, the demo runs on a simulated Echo Show (and an Echo Dot): the open-source Alexa+ simulator I built for this entry, with one Corral extension. It's a real MCP client of the server (every initialize, tools/list and tools/call shows in its traffic log), with Claude deciding what to say and do, voice in and out, a picker for who's speaking, the MCP Apps screens on the device, and a Readiness tab that checks this server against Amazon's published requirements from your browser.

What's real and what's simulated:

Real: Corral, running my family and the ranch every day; this MCP server and its account linking, deployed and linked end to end to that live Corral; the greenhouse misters, switched through this server on camera; Claude Opus 5.5 deciding every answer in the demo; Amazon Polly's voice; the live Open-Meteo forecast; each person's rules, enforced by Corral; the shared household across devices; the ordering rules (cents, the spending limit, who approves).
Simulated, and why: Alexa+ itself (its developer tools are partner-only, so the simulated Echo Show and Echo Dot are real MCP clients of the same server); who's speaking (voice profiles aren't open to add-ons, so a picker says who's talking); the demo household (made up, so judges never see my family's data); the dogs' GPS collars, the heaters and the feed store in the demo (sample connectors; no money moves); the greenhouse in the hosted demo (the controller is on the ranch's network, so the hosted demo uses a simulated one with the same limits); proactive delivery (MCP can't push, so the simulator polls a screen-only tool).

How it meets the judging criteria

Technical implementation. One stateless endpoint serves the 2025-11-25 protocol the track asks for and the current 2026-07-28, and answers the 2025-03-26 initialize Amazon's documentation shows Alexa+ sending. Account linking follows Alexa's published contract (root metadata, bare 401, fixed client, PKCE, refresh tokens) and works end to end against the live Corral. Tool calls take 10 to 20 ms of server time, well inside Alexa's 500 ms budget. 304 tests cover both protocol eras, every screen, every role, ordering, automations and linking, including 24 property tests (fast-check, from a fixed seed) over money, who approves, device limits, the household clock and the fence geometry, which caught a real bug before judges could. CI runs the suite twice, the second time on a machine clock at UTC+14, and a scheduled check tries the live demo twice a day: the page, MCP, a real model turn and Polly.
Design. Screens sized to read across a kitchen, with tabs on a rail out of the way of anything Alexa floats over the top. A tap on the screen tells the assistant what changed, so "who did the eggs?" right after already knows. Spoken answers lead with the answer, a sentence or two, then offer the next step; on an Echo Dot, with no screen, the same request is answered fully in words.
Potential impact. Every household with more than one adult, kids old enough to ask, someone to care for, or animals to feed has this problem. A busy family deciding who drives; an aging parent whose pills are on a schedule, where a late dose is said out loud and a caregiver can ask "did Mom take her pill?"; a farm or ranch where the animals have to be safe tonight. The people who most need a shared system are the ones a voice assistant serves worst today, because one account can't hold everyone's rules. And it's already real: my family and the ranch run on Corral every day, which is how I know these are the requests that matter. Corral is a platform: devices, stores, automations and roles are data and connectors, never code paths, so the same server runs a city apartment, a caregiver's home or a cattle operation.
Quality of the idea. It uses what only Alexa+ has (who's speaking, a screen in the kitchen, a voice in the barn) for the thing a family actually argues about: who does what, who decides, and whether the animals are safe tonight. Each of the track's asks is in it: a multi-service agentic workflow (the freeze), state across sessions and devices, purchasing, cards and a carousel, MCP Apps and an Agent Skill. And the simulator I built to show it is now a tool every Alexa+ builder can use.

How I built it

MCP server on Cloudflare Workers with the MCP TypeScript SDK v2: one stateless endpoint serves Alexa+'s and current clients. Linked, each call goes to Corral's own MCP server with the person's Corral token; a built-in sample household answers the same tools with the same JSON for demos.
Account linking to the Alexa+ MCP Toolkit's published contract: OAuth 2.1 with PKCE, protected resource metadata at the root, a fixed client and no dynamic registration, a bare 401 before linking, refresh tokens. Built on Cloudflare's workers-oauth-provider, with Corral's own consent page as the sign-in and Corral's tokens kept encrypted in the grant.
MCP Apps screens following the official patterns: a screen-only refresh tool, polling that pauses offscreen, full screen, host fonts, model-context updates, and self-contained pages that reach no other origin. Since a screen can't open another screen without a model turn, Today, Ranch, Animals and Automations are tabs in one bundle.
The ranch is connectors: a device source (the ESP32 greenhouse controller on the LAN, or a sample), the Open-Meteo forecast, GPS collars with fence geometry, and device limits (a mister runs at most so long) that apply to voice, taps and automations alike.
Automations are data: a trigger (a schedule, a freeze forecast checked at a time, or a sensor reading below a level), conditions and steps. They run when the ranch is next touched, checked against the same limits, and say in plain words what they'll do.
Ordering is a supplier connector: a catalog of what a store sells for which supply, in what unit, at what price and how soon, and a way to place an order. A spending limit and the household's roles decide whether an order goes through or waits for a parent.
State across sessions and devices: the demo's sample household is a SQLite-backed Cloudflare Durable Object that serves MCP from inside itself, one per household, with its own clock (so a visitor can make it evening and see the night's story at any hour). Screens poll a cheap change counter every 3 seconds and refresh when it moves, since a stateless MCP endpoint can't push.
The simulated Echo Show is the open-source Alexa+ simulator I built (alexa-plus-simulator), with one Corral extension (echo/corral.ts) for who's speaking, the demo passcode, Amazon Polly, the household's clock, the alerts and the scripted demo. Web Speech listens; Amazon Polly speaks (neural Joanna, about half a second before it starts talking, with the browser's voice as a fallback). /echo?devices=2 runs a kitchen Echo Show 8 and a barn Echo Show 5, each its own MCP client, conversation and screen.
Claude Opus 5.5 is the simulator's brain, through the Claude API, or Amazon Bedrock when the account can run it (one setting picks; any other Bedrock model goes through the Responses API, translated so the page doesn't change): low effort for quick replies, a cached system prompt built from the Agent Skill, a refusal fallback, rate limiting and a passcode.
An Agent Skill (corral-household) for any agent, also served as an MCP prompt.

Challenges I ran into

No way to reach a real Alexa+. The MCP Toolkit, CLI and web simulator are partner-only, which the setup pages don't say. I built to the published contract and made a faithful simulator instead, then opened it up for everyone.
Alexa's discovery differs from the MCP spec. Alexa reads protected resource metadata only at the root, and the 401 challenge header the MCP spec describes breaks its account linking (the Alexa team confirmed it); standard OAuth libraries serve the metadata under the resource path. The server serves the root document itself and sends a bare 401. I proposed a root option upstream (cloudflare/workers-oauth-provider#414); the maintainers declined it, since RFC 9728 puts the document under the path, so the workaround stays in the server.
Two protocol eras at once. Alexa+ asks for one protocol version while current clients speak 2026-07-28; one stateless endpoint serves both.
Live updates without a push channel. Stateless MCP has no server notifications, so two Echo Shows couldn't tell each other about a change. The household keeps a change counter that screens poll cheaply, and the household moved from Worker memory into one Durable Object per household.
Shared devices. A kitchen Echo is used by everyone. Linking it as one adult would read that adult's private things aloud, so the bridge keeps every rule in Corral, and who's talking decides what's allowed.
Screens that move without the model. An MCP App can only reach another screen through the assistant, which is too slow for a touch screen; I merged the home screens into one bundle with tabs, and filed it as a feature request.

Accomplishments that I'm proud of

A real account link from an Alexa-style client to my family's live Corral, through Corral's own consent page, with tokens refreshed.
The real greenhouse misters, switched by voice through this server.
One spoken sentence that reads five systems, acts after one yes, orders what's low, and then keeps doing it on its own.
An open-source Alexa+ simulator and readiness check that any add-on builder can run, which this demo runs on.
The same server working in Claude with no changes, screens and all.

What I learned

MCP-first is the right bet: one server and one skill served Alexa+, Claude and the simulator without changes.
Keeping authorization in the system of record, not in the bridge, makes the voice layer simple and safe.
Voice and touch want different answers: a sentence out loud, the whole picture on the screen.

What's next for Corral for Alexa+

Certify the add-on as soon as partner access opens; everything is built to the contract.
A real store behind the supplier connector, and the household's own spending rules from Corral.
Proactive moments: "the farrier's here in 20 minutes", "Leia's pill is late", "the freeze automation turned the heaters on."