A small change to my TV home screen could turn into a surprisingly long trip through menus, all with the remote.
My setup runs Kodi, a free, open-source media-centre app for playing and organising video, music and other media. Add-ons extend what it does, and skins change the interface. Mine runs on an NVIDIA Shield, an Android TV box.
Updating the home-screen rows was the job that finally pushed me to build something. Into the skin settings, Add widget → Video add-ons → TMDb Helper → Movies. Pick a folder, return to Home and find out what it actually contained. If it was empty, slow or wrong, back into settings. Then repeat for the next profile.
I wanted to manage the setup from my desktop, with a keyboard and enough screen space to see what I was doing. I couldn't find something that met my needs, so I started building a web UI. That became Kodi Manager.
Eventually, I gave an agent access through nvidia-MCP. That made debugging and customisation much quicker. It could read the logs, inspect the actual configuration and work through changes with me.
Now I can describe how I want the setup to behave and have it investigate what needs changing, from a setting to the code behind a feature. That is what keeps making these tools useful as my setup changes.
This is built for any Android box with ADB access over the network. The Kodi features also need Kodi installed with HTTP remote control enabled. Android TV, Google TV and Android-based Fire TV are covered by the device setup guide. My day-to-day hardware testing is on a Shield; individual controls depend on the device and firmware.
First, a way to manage it from my computer
Kodi Manager runs inside Kodi and serves an authenticated browser dashboard. It gives me one place to search add-on settings, compare saved values with defaults, inspect playback routing, read logs and make supported changes with backups. The dashboard works independently of an agent and doesn't need ADB.
The real dashboard with synthetic demo data: example device and service readings.
The useful part is seeing the relationships. Which add-on supplied a row? Which helper hands it to which player? Which add-ons declare a dependency on one I'm considering removing? A settings screen on the TV rarely shows all that context together.
For the home-row job, Home layout lets me preview folders from installed add-ons before choosing them, edit a draft and review the complete row list before applying it. Rebuilding the skin menu is a separate visible step.
15-second edited demo of the real dashboard with synthetic titles and folder responses. No TV or provider was connected. It stops at review, before Apply.
The layout implementation checks the revision I started from, so an old draft can't silently overwrite a newer layout. Its write support is deliberately specific to reviewed Bingie and Skin Shortcuts versions with matching source hashes. The rest of the dashboard covers much more than that layout editor.
Existing projects such as Chorus2 already provide browser control of Kodi. My focus was the configuration and troubleshooting work around a customised setup.
Then the agent could work with the actual setup
nvidia-MCP runs on my computer. It connects to Kodi's HTTP interface and Android Debug Bridge, or ADB, which exposes authorised debugging access to the Android device. MCP—the Model Context Protocol—is how an assistant discovers and calls the tools the server provides. Connecting Kodi Manager adds its structured settings, diagnostics, backup and layout operations.
The difference is how much context the agent can gather for itself. I can describe the problem, and it can inspect the installed versions, active profile, settings, files, logs and device state before suggesting a change.
| What I want to do | What the agent can work with |
|---|---|
| Understand a problem | Kodi and Android logs, playback state, device status and installed versions |
| Find the relevant configuration | Add-on settings, defaults, profiles, routing and supported text files |
| Change the setup | Supported settings and file repairs, reviewed layouts, cache refreshes and backups |
| Build something new | Local project source, build tools and custom scripts in my coding agent's development environment |
| Check the result | Read-back values, new logs, UI/device observations and recovery information |
That last distinction matters. The packaged MCP server supplies defined Kodi and device operations. My coding agent also has access to the local projects and build/deployment scripts, which is how it can help develop a skin change, an Android helper or a separate integration. Together, those give me a much wider way to work on the setup.
There is no fixed list of customisations I want. Sometimes it's finding the setting that already exists. Sometimes it's changing the interface or building the missing behaviour. The agent can investigate the relevant layer and help me implement it within what the device and software support.
Read the logs, find the cause, check the fix
Troubleshooting used to involve fetching another piece of information for each question: a setting, a version, a screenshot or a log. Giving the agent access lets it follow the investigation through.
For example, I can ask:
Kodi is slow and one home row keeps failing. Check the current and previous logs, the add-on versions and the relevant settings. Explain what you find before changing anything.
All example requests in this post are illustrative, not transcripts.
It can read bounded Kodi log tails and, for problems below Kodi, Android logs. The dashboard also makes retained errors and warnings searchable. Settings returned through Manager include labels, types, options and defaults, so the agent gets more context than a bare XML value. Without Manager, the add-on-settings fallback reads saved XML only.
The workflow becomes inspect → explain → review a change → back up → apply → verify. Reading a plausible error message is a starting point. The fix still needs checking against the installed version, the actual settings and what happens afterwards.
One actual playback problem produced a green picture. The selected source was 4K HEVC Dolby Vision, while the display reported no supported HDR types. In the affected profile, POV—the playback add-on—had its Dolby Vision and HDR file filters set to Include. After backing up, changing both to Exclude while Kodi was stopped, and reading the settings back, subsequent live checks recorded 1080p H.264 SDR through the NVIDIA hardware decoder, with fullscreen playback advancing. That was the result for this display and source-selection problem; HDR settings should follow the display's capabilities.
Another investigation found that Android was starting a fresh Kodi process shortly after the original process had exited cleanly. A shutdown check mistook the new process for a hang. The fix tracks the original process IDs. Its regression tests simulate hangs and respawns; those tests and a live TV interaction establish different things.
The useful capability is being able to investigate across the application, its add-ons and the device, then check whether the change actually addressed the problem.
Customise the interface, the behaviour and the integrations
I can work on how the home screen looks, how navigation behaves, which sources supply its rows, how profiles are separated and what happens when I press a button. When that needs code, the coding agent can help inspect the source, make the change, build it and test it.
Voice search crossed several layers. On the tested Shield firmware, Android intercepts the remote's KEYCODE_ASSIST, so a Kodi keymap couldn't send it into the skin's search. With agent-assisted development, I built an Android helper that recognises speech and sends the text to Manager's authenticated local POST /api/search/voice endpoint. Manager opens Bingie's search and records the query in the current profile.
I've tested pressing the remote's mic, speaking a query and getting the right Bingie results on my Shield. The reusable integration lives in Bingie Companion, with an optional on-screen microphone in my maintained Bingie skin fork. They install separately. Assigning the physical mic is a separate owner choice; the on-screen action leaves the system assistant choice alone. The speech provider may process audio over the network.
My working installation and the latest standalone revisions have separate acceptance records. The package test notes cover earlier on-TV checks; the latest extracted revisions still have hardware and spoken-recognition acceptance pending in those records.
An illustrative request could be:
I'd like voice input to open the search I already use. Investigate how the mic button is routed, work out what needs changing, and keep typed search available.
The same approach applies to a different skin behaviour, a custom helper or an integration with another service: understand the existing path, work on the right component and verify the result.
What that flexibility has let me do
The jobs I've given it have become much broader than the home-row changes that started this.
Separate the kids' viewing. I used the agent to move selected children's and family viewing into a Kids Kodi profile with its own, parent-managed Trakt account. Trakt keeps watch history and lists; the move preserved original dates, repeat watches, paused positions, and selected ratings and watchlist entries. The destination was checked before matching originals were removed from the main account. Profile-local caches and actual listings were checked afterwards, and the adult Continue Watching and Recently Watched previews no longer contained the transferred titles.
That was custom Trakt API and profile work in my development setup. Account linking and authorisation are separate, private steps; the public MCP tools refuse credential edits.
Create discovery lists that keep themselves current. I used the agent to build UK TV Zeitgeist, a separate updater that maintains ordinary Trakt lists feeding Kodi rows. It combines BARB's published programme chart, Netflix's UK TV Top 10 and JustWatch's UK charts when available. It estimates attention from those different signals, resolves titles to stable series IDs and deduplicates them. It doesn't measure social conversation or everything watched in Britain.
The updater snapshots lists before changing them, verifies additions before removing obsolete entries and guards against incomplete data. It runs daily on GitHub Actions with its own Trakt session, so the Mac and TV box don't need to be awake. The scheduled runs were succeeding when I checked them for this post.
Change how home rows load. Manager's optional cache serves the last listing from disk and refreshes sources one at a time while viewing is idle. Recorded measurements on one Shield running Kodi 22 beta 2 and Bingie put the Favourites page at about six seconds with direct rows and half a second with cached rows. The first load still fills the cache; later listings can be stale, and failed refreshes retain the last complete listing.
Those are things I've actually done with this setup. The broader value is being able to describe the next problem or customisation and work through it with an agent that can inspect the software behind the screen.
What you need to try it
For the Android setup, you'll need a computer on the same network, Python 3.11+, an MCP-capable assistant, network-accessible ADB on the Android box, and Kodi with HTTP control enabled for the Kodi tools. The Android device guide covers Shield, Android TV, Google TV and Android-based Fire TV. USB debugging alone doesn't necessarily provide network access. Individual features depend on the device, firmware and Kodi/skin versions.
Kodi Manager is optional for nvidia-MCP. You can also use just its browser dashboard. There is experimental Apple TV support through a separate backend; it doesn't use ADB and has no physical Apple TV validation.
Both main projects are prerelease, and my live hardware experience is with one customised Shield. nvidia-MCP starts read-only, write tools require an opt-in, and Manager has its own write mode. Supported file repairs use reviewed edits and matching checksums; layout plans are tied to the profile and revision. Disruptive operations check playback and the foreground app, since another Android app can be playing while Kodi reports no active player.
The tool reference and repair workflows describe the packaged operations. Custom features use the additional source/build access I've described above.
Start with Kodi Manager's setup guide, open the dashboard and inspect a setting or a log. Connect nvidia-MCP when you want the assistant to work with that information. Both main projects are open source.
I started because changing rows with a remote was a chore. The browser gave me a practical way to manage the setup. Agent access made the investigation and development work much easier too. Now I can work on the configuration, the interface and the code behind it, from my desktop, with an assistant that can see what is actually there.
What would you change about your TV setup if you could work on it with a keyboard, logs and an agent?
These are personal projects developed with AI assistance. AI also helped research and draft this post.
Top comments (0)