<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Brendon Smith on Medium]]></title>
        <description><![CDATA[Stories by Brendon Smith on Medium]]></description>
        <link>https://medium.com/@seacloud9?source=rss-dcf3b2ca8a97------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*RUaBOyt7K0X_uuXl.</url>
            <title>Stories by Brendon Smith on Medium</title>
            <link>https://medium.com/@seacloud9?source=rss-dcf3b2ca8a97------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:40:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@seacloud9/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Nova64 meets RetroArch and Jellyfin. Scene Weaver is coming next.]]></title>
            <link>https://medium.com/@seacloud9/nova64-meets-retroarch-and-jellyfin-scene-weaver-is-coming-next-6900afd0c1f7?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/6900afd0c1f7</guid>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Tue, 10 Nov 2026 23:05:37 GMT</pubDate>
            <atom:updated>2026-11-10T23:07:03.336Z</atom:updated>
            <content:encoded><![CDATA[<p>Playable cartridges, native and browser runtimes, and a first look at Scene Weaver: connect 3D worlds into an adventure in m{ai}geXR.</p><p>I wanted the feeling of pulling a cartridge off a shelf, plugging it in, and finding a world inside. That’s the idea behind Nova64. The surprising part of this update is where that shelf can live now. One place is a browser tab. Another is a <a href="https://github.com/seacloud9/jellyfin-retroarch-plugin">Jellyfin</a> library.</p><p>Meanwhile, I’ve been working on the other end of that experience in m{ai}geXR. How quickly can you get from a sentence to a scene you can run, change, and hand to a friend?</p><h4>Pick a cart. Then switch the renderer.</h4><p>Open the Nova64 console and start with Breakwater Circuit or F-Zero Nova. Then try Crystal Cathedral, where you can take your time looking at the graphics. The console puts Three.js and the experimental Babylon.js backend a click apart. Try a cart on both and look at how each backend handles the scene. It’s the sort of experiment I wish I’d had when I was learning 3D.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*13hkXlg7Uh4zZjLfpf95zw.png" /></figure><p><a href="https://nova64.io/console.html?demo=f-zero-nova-3d">Play F-Zero Nova</a> · <a href="https://nova64.io/console">Browse the console and switch renderers</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*73Zp1CySGYwTqStX5mnoLg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/832/1*oDxZsQ8ZG6JsJCRXAoWxbw.png" /></figure><h4>RetroArch and RetroBridge: a new home for Nova64 cartridges</h4><p>Nova64 now has native and WebAssembly (WASM) support through its <a href="https://github.com/seacloud9/nova64/tree/main/retroarch">RetroArch core</a>. The native path brings a Nova64 cartridge into a RetroArch setup. The WASM path brings the runtime into a browser. That gives the same cartridge more places to be played beyond the editor where it began. The <a href="https://github.com/seacloud9/nova64/releases">Nova64 releases</a> and <a href="https://github.com/seacloud9/nova64/blob/main/retroarch/README.md">RetroArch installation guide</a> are the places to start.</p><p>RetroBridge for <a href="https://github.com/seacloud9/jellyfin-retroarch-plugin">Jellyfin</a> takes that idea into a game library. The prototype catalogs .nova cartridges and provides paths for a desktop companion, Android app and browser playback. The recent Nova64 integration also makes bundled demos available before you scan your own library. I love seeing a cartridge I built become something I can browse and choose from a shelf.</p><p>The <a href="https://github.com/seacloud9/jellyfin-retroarch-plugin">RetroBridge source and setup guide</a> explain the current installation and playback options. It is still a prototype, with compatibility and device testing in progress. The <a href="https://github.com/seacloud9/jellyfin-retroarch-plugin/blob/main/docs/verification.md">verification record</a> separates tested behavior from the checks that remain.</p><h4>Three games from three sentences</h4><p>On the m{ai}geXR side, I’ve been using Qwen to build starter templates. The walkthrough below shows three games made from one sentence each on an Android tablet and an iPad, with Qwen3–30B running locally on a Mac. The waits for the model are sped up. The app interaction is real.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u6Dj6mniIPwLtWEFgYCZ5Q.jpeg" /></figure><p><a href="https://maigexr.seacloud9.studio/#demo">Watch the m{ai}geXR walkthrough</a> · <a href="https://maigexr.seacloud9.studio/maigeXRpromoVemo.mp4">Open the video directly</a></p><h4>Coming soon: Scene Weaver connects 3D worlds through portals</h4><p>Once a template runs, I want it to lead somewhere. Scene Weaver is a coming feature in m{ai}geXR that lets me connect scene cards into a route, then play that route as a journey through 3D worlds. Each card is a scene. Each connection becomes a portal to another place.</p><p>The new Rift Run demo shows both sides of that process. First you see the Scene Weaver graph. Then the journey takes you through Verdant Ruins, Ember Causeway and Starfall Citadel. The map explains what connects; the playable scenes show what those connections feel like.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/360/1*q5TAyRfK9ktpqafk_GjGOg.gif" /></figure><p>Scene Weaver in action: a 33-second animated preview.</p><p>Scene Weaver’s Rift Run demo, captured in the iOS simulator. This guided tour uses automatic travel through three authored starter worlds.</p><p>The portals have animated interiors and illuminated frames, and they sit inside the scene. The camera aims toward the portal and flies through its actual location before the next scene opens. I also added a portal visibility toggle, clearer scene thumbnails and a Play this journey button.</p><p>This is a preview of the current development build, not a claim that Scene Weaver is already available in the App Store version. You can explore <a href="https://maigexr.seacloud9.studio/">m{ai}geXR</a> and follow the <a href="https://github.com/m-ai-geXR/iOSMaigeXr">iOS source on GitHub</a>.</p><p>I’m also working toward Facebook Instant Games support so these small games have another place to reach people.</p><p>Start with a <a href="https://nova64.io/console">playable Nova64 cartridge</a>, explore the <a href="https://github.com/seacloud9/nova64/blob/main/retroarch/README.md">RetroArch setup</a>, or follow <a href="https://github.com/seacloud9/jellyfin-retroarch-plugin">RetroBridge for Jellyfin</a> on GitHub. For the creative side, watch the Scene Weaver demo above and follow <a href="https://maigexr.seacloud9.studio/">m{ai}geXR</a> for what comes next. What worlds would you connect first?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6900afd0c1f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[m{ai}geXR Is on the App Store, and the Nova64 Playground Keeps Growing]]></title>
            <link>https://medium.com/@seacloud9/m-ai-gexr-is-on-the-app-store-and-the-nova64-playground-keeps-growing-aa4b5fb6ab92?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa4b5fb6ab92</guid>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 00:20:30 GMT</pubDate>
            <atom:updated>2026-11-09T00:20:30.165Z</atom:updated>
            <content:encoded><![CDATA[<h4>Game templates, remote access to local Qwen, and WebAssembly powered RetroArch in our WebOS shell are bringing the pieces together.</h4><p>There is a special kind of excitement when projects you have been building start making each other better.</p><p>That is where I am with m{ai}geXR and Nova64 right now.</p><p>m{ai}geXR has made it through App Store approval and is available for iPhone and iPad. We have added game templates that give AI a stronger starting point. You can connect the app to your own model server and use it to direct Qwen running on another machine. And on the Nova64 side, we have recently enabled WebAssembly builds of the RetroArch core, with the browser experience demonstrated inside our WebOS shell.</p><p>Each of those is a satisfying milestone on its own. Together, they suggest something I have wanted for a long time: a more approachable way to move from an idea to an interactive world you can actually play with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*qY0OeA9GnlzWJdU7.png" /><figcaption>Ember Mine Dash: a Nova64 runner title screen from the local Qwen Studio experiment.</figcaption></figure><h3>App Store approval makes the project easier to share</h3><p><a href="https://apps.apple.com/us/app/m-ai-gexr/id6819833777">m{ai}geXR is now available on the App Store</a>, with version 1.1.1 bringing Nova64 game templates, code checks, and support for local AI models.</p><p>The app is a pocket studio for interactive 3D. You describe an idea, the assistant generates code, and you explore the result in a playground. You can revise the prompt, inspect the code, and keep working on the scene.</p><p>The current app supports Babylon.js, Three.js, A Frame, React Three Fiber, and Nova64. Built in examples offer a place to begin, and scene export gives you a way to continue on a computer.</p><p>For me, approval is a meaningful moment because it changes how I can introduce the project. There is now a familiar place to download it and try it.</p><p>Someone can hear about the idea, install the app, and begin exploring. That shorter path matters, especially for people who are curious about creative coding but would rather start with something visible than an afternoon of setup.</p><p>You can also find the project at the <a href="https://maigexr.seacloud9.studio/">m{ai}geXR website</a>.</p><h3>Why Nova64 belongs in this studio</h3><p><a href="https://nova64.io/">Nova64</a> is a retro 3D fantasy console. It gives small games a deliberately focused environment, with a recognizable visual character and an API for building interactive experiences.</p><p>That makes it a useful creative partner for m{ai}geXR.</p><p>A fantasy console gives an idea some boundaries. There is a place for the game to run, a vocabulary for expressing it, and a manageable scale for experimentation. Those boundaries can help a person get started, and they can help a model produce something coherent.</p><p>I like the thought of someone asking for a strange little dungeon, seeing it take shape, and then opening the code to understand how it works. The initial prompt gets them moving. The editable result gives them somewhere to go next.</p><p>There is room for learning, tinkering, and making something delightfully specific. A tiny game about collecting crystals in a haunted cave is a perfectly respectable use of computing power.</p><h3>The lesson from teaching local Qwen to make games</h3><p>I recently wrote about the experiment in <a href="https://blog.starcade9.io/i-taught-a-local-ai-to-make-retro-games-the-trick-was-giving-it-less-to-do/">I Taught a Local AI to Make Retro Games. The Trick Was Giving It Less to Do.</a></p><p>The early approach asked Qwen to build too much at once. It had to invent the game, remember the API, write the mechanics, choose the visual style, and make everything work together. Some results were entertaining for reasons I had not intended.</p><p>The useful breakthrough was to provide complete game engines with a clearly defined configuration section. Qwen could then concentrate on the title, story, palette, characters, enemies, atmosphere, and difficulty.</p><p>The engine supplied the movement and game systems. Checks and browser testing helped evaluate the result. The model still had a creative job, but that job had a clearer shape.</p><p>That experiment became a practical direction for the product. We now have templates in m{ai}geXR that bring the same division of work into the creation experience.</p><h3>Templates give the model a stronger foundation</h3><p>The current template collection has six starting points across three game families.</p><p>There are first person dungeon crawlers in torchlit stone and neon grid styles. There are lane runners with neon tracks or torchlit corridors. And there are arena dodgers set in a neon environment or a crystal cave.</p><p>Each family gives the creator a different kind of game to shape. A dungeon can have a party, encounters, a boss, and an exit to reach. A runner can build its rhythm around switching lanes, jumping hurdles, collecting pickups, and surviving increasing speed. An arena game can revolve around movement, dashing, collecting gems, and reading approaching threats.</p><p>The important part is how the generation works. When a template is selected, the model writes its configuration, and the app combines that configuration with the existing engine. The model is given a smaller, more understandable creative task.</p><p>The interface also includes keyword chips for previewing templates, and the chat indicates which template provided the starting point. That makes the process easier to follow. You can see the structure you are building on before asking for a variation.</p><p>As a hypothetical example, imagine asking for a crystal cave arena with violet enemies, bright amber gems, and a gentler opening wave. That request describes the experience you want to shape. The template supplies the arena mechanics underneath it.</p><p>This feels like a useful direction for AI assisted tools: give people expressive controls over something with a reliable foundation, then let them iterate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*pEm1EYtOlcRrIJMv.png" /><figcaption>Frost Crypt of Ymir: a story screen from the local Qwen Studio experiment, pairing a dungeon setting with a generated narrative.</figcaption></figure><h3>Checks help keep the creative loop moving</h3><p>Templates are one part of the improvement. The generated code also passes through checks that catch specific, recurring mistakes.</p><p>The shared Nova64 kit can normalize API imports, flag unknown API names, identify syntax problems, and check for missing lifecycle functions. For 3D carts, it also removes a screen clearing pattern that can cover the scene.</p><p>When supported checks still find problems, the chat can send a focused repair request back to the model. That repair loop is limited to two attempts per user message, and it keeps the better version if a later attempt introduces more reported problems.</p><p>There is a useful distinction here. The earlier local Qwen Studio experiment includes browser play checks and screenshot analysis. The app’s current repair loop checks code; it does not yet inspect the rendered image or automatically repair runtime errors.</p><p>A successful code check is one useful signal. Playing the game still tells us things that code checks cannot.</p><p>That is also why I find this progress encouraging. Each recurring mistake gives us a specific opportunity to improve the tool. A clearer check, a better template, or a more useful repair message can make the next creative attempt easier.</p><h3>Your phone can direct Qwen on your own machine</h3><p>One of my favorite additions is the ability to connect m{ai}geXR to a local model server.</p><p>The iOS implementation lets you configure a server address and model name for an endpoint that supports the OpenAI compatible chat completions API. That opens the door to using a model hosted on your own machine, including a compatible Qwen setup.</p><p>This is what I mean by using m{ai}geXR to remotely control Qwen: the app acts as the creative interface, sends your prompts to the configured server, and receives the model’s replies. Qwen runs on the machine hosting it.</p><p>The phone does not need to run that model itself. It needs a working connection to the server. On a suitable network, you can hold the interface in your hand while your computer handles inference.</p><p>That separation is exciting. The machine you use for computation and the device you use to express an idea can be different machines.</p><p>It also makes the template approach more valuable. A model running on personal hardware benefits from a focused task just as much as any other model does. Asking it to shape a configuration gives it a clear role in a larger creative system.</p><p>In practical terms, the setup begins with a compatible model server, its reachable address, and the model name configured in the app. Access from outside your home network needs an appropriate private connection or authenticated access setup. The app setting supplies the destination; your network supplies the route.</p><p>The broader appeal is simple: I want to be able to reach for a device, describe something interesting, and work with the tools I already have running.</p><h3>RetroArch in WebAssembly is a particularly fun milestone</h3><p>On the Nova64 side, we have also recently enabled the RetroArch core’s WebAssembly path and brought the experience into our WebOS shell.</p><p>Nova64 has a libretro core for running carts through RetroArch. That core can be compiled to WebAssembly and linked into RetroArch’s web player. The result gives us another way to run Nova64 carts in a browser.</p><p>Our WebOS shell now includes a RetroArch Web app with a cart selector and an embedded player. It demonstrates the Nova64 core running through the RetroArch web environment inside the shell.</p><p>Here, WebOS means our browser based desktop shell. It is the desktop style environment around these tools and games.</p><p>The technical distinction is interesting: Nova64 already has a browser runtime, while this route brings its C based libretro core into the browser through WebAssembly. It gives us another implementation to exercise, compare, and improve.</p><p>It is also simply fun to open a desktop style shell, launch RetroArch Web, choose a cart, and see these parts meet in one place.</p><p>The work is still developing. Different runtimes have different capabilities, and some carts depend on features that are specific to a host. We are continuing compatibility work rather than claiming every cart behaves identically everywhere.</p><p>But the direction is tangible. The core build, player files, shell app, and recorded browser testing now give this idea a concrete form.</p><h3>The pieces are starting to reinforce each other</h3><p>What makes this moment satisfying is the relationship between these projects.</p><p>m{ai}geXR gives people an interface for describing, generating, and editing interactive scenes. Nova64 gives small games a focused creative environment. Templates turn common game structures into useful starting points. A local model server lets personal hardware participate in that workflow. And the WebOS shell gives the growing Nova64 environment a playful place to explore.</p><p>The WebAssembly RetroArch work adds another route for running and testing carts. It belongs to the broader Nova64 project; it is separate from the features listed for the iOS app.</p><p>These connections make the work feel cumulative. Improving the template system helps the creation experience. Improving runtime compatibility gives games more room to travel. Improving the interface makes the whole process easier to approach.</p><p>That is the kind of progress I enjoy most: improvements that make the next improvement more useful.</p><h3>A good time to start making things</h3><p>App Store approval is worth celebrating. So is reaching the point where a local model, a mobile interface, tested game templates, and a growing set of runtimes can take part in the same creative story.</p><p>There is plenty left to build. I want better feedback, stronger templates, broader compatibility, and more opportunities to learn from what people make.</p><p>For now, I am happy to see m{ai}geXR and Nova64 coming along together. The tools are getting easier to reach, the starting points are becoming more useful, and the playground keeps expanding.</p><p>If you would like to explore, visit the <a href="https://maigexr.seacloud9.studio/">m{ai}geXR website</a>, download <a href="https://apps.apple.com/us/app/m-ai-gexr/id6819833777">m{ai}geXR from the App Store</a>, or take a look at <a href="https://nova64.io/">Nova64</a>.</p><p>Start with a small idea. Give it a strange name. See what it becomes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa4b5fb6ab92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Make a Game by Describing It: Introducing m{ai}geXR]]></title>
            <link>https://medium.com/@seacloud9/make-a-game-by-describing-it-introducing-m-ai-gexr-c7dbb7a59048?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7dbb7a59048</guid>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[indie-game]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[webxr]]></category>
            <category><![CDATA[education]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 23:35:43 GMT</pubDate>
            <atom:updated>2026-11-04T23:35:43.569Z</atom:updated>
            <content:encoded><![CDATA[<h3>Our AI studio for 3D and XR is out now on Android, with iOS coming soon. We studied Google’s playground, then set out to make game creation that easy, on more platforms, with better-looking results.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q03CcJ5uVwtDn48n9TUCww.png" /></figure><p><strong>stArcade9</strong>Nov 4, 2026 · 6 min read</p><p>Earlier today we wrote about <a href="https://blog.starcade9.io/i-taught-a-local-ai-to-make-retro-games-the-trick-was-giving-it-less-to-do/">teaching a local AI to make retro games</a>. The lesson from that project was simple: a model makes better games when it has less to do. Let the engine handle the parts that must be correct, and let the model handle the parts that should be interesting.</p><p><a href="https://maigexr.seacloud9.studio/">m{ai}geXR</a> is where we put that lesson in front of everyone. It’s available now on the Google Play Store, and it’s coming soon to the Apple App Store.</p><h3>What it does</h3><p>You describe a scene in plain English. m{ai}geXR writes the code for the 3D framework you picked, runs it right away in a built-in playground, and keeps editing it as you keep talking.</p><blockquote>Create a glowing green planet with rings and three orbiting moons.</blockquote><p>Then you keep going: “make the planet blue,” “add stars,” “speed up the moons.” Each message changes the scene you already have instead of starting over. A game grows the same way, one sentence at a time.</p><h3>What we learned from Google’s playground</h3><p>Before building, we spent time with <a href="https://playground.google/explore/all">Google’s playground</a>, a gallery of games and apps made by describing them to AI. What stood out was how little effort it asks of you. You type an idea and you get something you can play.</p><p>We wanted that same starting point for m{ai}geXR. We also saw two places to go further: where your work can go once it’s made, and how good it looks.</p><h3>Easy from the first message</h3><ul><li>One chat window and a running scene next to it. No project setup.</li><li>An examples browser with ready-made scenes for every framework, so you never start from a blank page.</li><li>Favorites and full conversation history, so you can return to a game and keep working on it.</li><li>Your choice of AI: Google AI, OpenAI, Anthropic, xAI or Together AI, including free models. A Google AI Studio key has a free tier and needs no card.</li></ul><h3>Many platforms to build on and share to</h3><p>m{ai}geXR runs on Android today, on iPhone and iPad soon, and as a desktop app for macOS, Windows and Linux. Your scenes and history follow the same design on every one.</p><p>What you make is ordinary, readable web code for open frameworks, so it isn’t locked inside the app. Pick the engine that fits where you want your game to end up:</p><ul><li><strong>Babylon.js</strong> and <strong>Three.js</strong> for games that run in any browser.</li><li><strong>A-Frame</strong> for WebXR, so scenes can be viewed in VR and AR.</li><li><strong>React Three Fiber</strong> and <strong>Reactylon</strong> for people building inside React apps.</li><li><strong>Nova64</strong>, a retro fantasy console with an N64 and PS1 look, for complete little games with a title screen and a story.</li></ul><h3>Graphics that hold their own</h3><p>We compared what we found in Google’s playground with what our engines produce. With Nova64’s low-poly 3D, cel shading, real lighting and fog, we think the results are on par, and often better.</p><p>Relic Diver’s town and ruins, and a Lanternfall boss fight, on a phone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z-uXf87FfP0rZRLt5gPjqw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u1aH7Gs4VEvfztmyech-HQ.png" /></figure><h3>A tool you learn from</h3><p>m{ai}geXR doesn’t hide the code. Every scene arrives as real source in a full code editor, right beside the result. When you ask for “make the planet blue,” you can see exactly which line changed and why.</p><p>That makes it a good way to learn. Students can pick a framework, ask for something, and read working code that uses that framework’s actual API. Then they can edit it by hand and run it again. Trying the same idea in Three.js and then in Babylon.js shows how two engines solve one problem.</p><p>Your history stays private. Searching your past scenes happens on your device, and nothing leaves it except the request you send to the AI provider you chose.</p><h3>Try it</h3><p>m{ai}geXR is on the Google Play Store now, and the iOS version is coming soon. Find links and updates at <a href="https://maigexr.seacloud9.studio/">maigexr.seacloud9.studio</a>.</p><p><em>If you make something with it, we’d love to see it.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7dbb7a59048" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Built a 3D Sneaker Launch in a Weekend — and Selling It Was the Easy Part]]></title>
            <link>https://medium.com/@seacloud9/i-built-a-3d-sneaker-launch-in-a-weekend-and-selling-it-was-the-easy-part-7588f2aba4ca?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/7588f2aba4ca</guid>
            <category><![CDATA[webgl]]></category>
            <category><![CDATA[threejs]]></category>
            <category><![CDATA[ecommerce]]></category>
            <category><![CDATA[freelancing]]></category>
            <category><![CDATA[nextjs]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Tue, 29 Sep 2026 16:33:11 GMT</pubDate>
            <atom:updated>2026-09-29T16:33:11.488Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>See it live: </strong><a href="https://contra.seacloud9.studio/sneaker-lab"><strong>contra.seacloud9.studio/sneaker-lab</strong></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v5DeoA2sbbgATGAmC2P9Cg.png" /><figcaption><em>The Studio view, the product floating above a dark pedestal, controls to the right</em></figcaption></figure><p><em>Studio mode. Neutral light, controlled shadow, every colourway reading true.</em></p><p>I wanted to find out how far you can get in a weekend if you stop treating a product demo as a big production.</p><p>The answer turned out to be: further than I expected, and with a lot more grinning than I expected. Here’s the whole thing — what I made, how quickly it came together, and how I put it somewhere people can actually hire me from.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F5BhuRq53YZE%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D5BhuRq53YZE&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F5BhuRq53YZE%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ca323d9ea0613b672bf720a16248d865/href">https://medium.com/media/ca323d9ea0613b672bf720a16248d865/href</a></iframe><h3>Two rooms, one shoe</h3><p>The idea is simple enough to explain in a sentence: a product stage with two personalities.</p><p><strong>Studio</strong> is the honest one. Neutral light, controlled shadow, calm motion — the mode a merchandiser signs off on, where the colour you see is the colour of the shoe.</p><p><strong>RetroFX</strong> is the launch moment. Cyan and magenta rim light, a glowing perspective grid, selective bloom, and a pixel dissolve that sweeps across the whole viewer as it switches.</p><p>Same geometry. Same materials. Completely different room. One click between them, and that click is genuinely fun to press — I have clicked it an unreasonable number of times.</p><figure><img alt="The Studio view, the product floating above a dark pedestal, controls to the right" src="https://cdn-images-1.medium.com/max/1024/1*rxhXFDCUoGIYonguaO_Mbg.png" /></figure><p><em>RetroFX mode, Electric Violet. The launch-night version of the same shoe.</em></p><p>Around that: three colourways, three camera presets that fly you to the sole, the upper and the heel, full orbit and zoom, and a second product you can swap to mid-session. Everything works with a keyboard. Everything works on a phone.</p><h3>The bit I keep telling people about</h3><p>Here’s my favorite thing in the whole build, and it’s an idea rather than a technique.</p><p>Most configurators wire colours directly to the names of materials inside the 3D file. It works right up until you get a different 3D file, and then it all falls over.</p><p>So this one talks in <strong>roles</strong> instead. Fabric. Rubber. Trim. Accent. Glass. A colourway says <em>“fabric is warm off-white and diffuse, trim is the only metallic surface”</em> — and each product separately says which parts of its own mesh count as fabric or trim.</p><p>Why that’s the good bit: the demo ships with a sneaker <strong>and</strong> a vintage flight helmet, and the same three colourways land beautifully on both. A running shoe and a leather-and-glass flight helmet, dressed by identical code. Switching between them is one button.</p><p>That’s the whole pitch for the approach, really. Build the system once, point it at whatever arrives next.</p><h3>It came together fast</h3><p>I’ll be honest about why this was quick, because I think it’s the useful part.</p><p><strong>Next.js did the boring half.</strong> Routing, the production build, image handling, the deployment target — none of it needed a decision. I wrote the interesting parts and let the framework have the rest.</p><p><strong>The product is data, not code.</strong> Adding the second product meant adding an entry to a config file. No component changed. When you decide early that the thing on screen is swappable, later-you gets a very easy afternoon.</p><p><strong>Deployment was genuinely a non-event.</strong> I pushed, pointed a domain at it, and it was live on a real URL with a certificate. The whole site sits under contra.seacloud9.studio, and it’s built so I can drop the next demo in beside this one at its own path without touching this one at all. That part I’m particularly pleased with — it’s a place for demos, not a demo.</p><p><strong>It’s a real page, not a video of a page.</strong> You can drag the shoe. That difference matters more than any amount of polish.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FX9S2mzbOyL0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DX9S2mzbOyL0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FX9S2mzbOyL0%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a33e419498ef11d125a87c1e4b770ba5/href">https://medium.com/media/a33e419498ef11d125a87c1e4b770ba5/href</a></iframe><p><em>The same thing on a phone. Swipe sideways to turn the shoe; swipe up and down to scroll the page like normal. That took one line of CSS and it’s the difference between “nice demo” and “I’d put this on my store”.</em></p><h3>Selling it was the easiest part</h3><p>This is the bit I actually want to talk about.</p><p>I’ve had periods of building good things and then doing nothing useful with them — they end up in a folder, or a repo nobody opens, and the work quietly evaporates. The gap between <em>made a thing</em> and <em>someone can hire me for this thing</em> used to feel enormous.</p><p>It isn’t any more. I have a Contra profile, the demo has a public URL, and the demo itself links straight back to the profile. That’s the entire funnel. Someone lands on a glowing sneaker, plays with it for thirty seconds, and there’s a button right there that says <em>build this for my product</em>.</p><p>No storefront to run. No checkout to maintain. No invoicing system to think about. Just: here is the work, here is the link, let’s talk.</p><p><a href="https://contra.com/seacloud9/"><strong>contra.com/seacloud9</strong></a></p><p>What I like about it is how little friction sits between making something and showing it to the right person. You finish the thing on Sunday, you point at it on Monday. That’s it. Turns out the hard part was never the selling — it was believing the selling had to be hard.</p><h3>What I build with</h3><p>Two of my own projects power this, and both are things I’ll happily build with for you.</p><p><a href="https://seacloud9.github.io/retro-fx/?path=/docs/docs-introduction--docs"><strong>RetroFuture FX</strong></a> — my library of retro-futuristic React components. Pixel dissolve, CRT, hologram, glitch, plasma, starfield. They’re the fun ones, and they’re built as proper React/Next.js primitives rather than a pile of shaders you have to babysit. The dissolve across the mode switch in this demo is written against its interface.</p><p><a href="https://seacloud9.github.io/model-orbit-forge/?path=/docs/productstage-3d-accessibility--docs"><strong>ProductStage 3D</strong></a> — my 3D viewer and configurator starter. A renderer-agnostic core, a Three.js adapter, schemas for variants and hotspots, and an accessible React viewer. The role-based material system I described above is its convention doing the work, and the two-products-one-colourway-set trick is the clearest proof I’ve got that the convention is a good one.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FTLGKHGd_bCg%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DTLGKHGd_bCg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FTLGKHGd_bCg%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd9fe5b284dc511fb1a50f3992e4c4ce/href">https://medium.com/media/bd9fe5b284dc511fb1a50f3992e4c4ce/href</a></iframe><h3>Want one of these?</h3><p>If you sell something that deserves to be seen properly — footwear, furniture, hardware, anything with material and shape worth looking at — this is the kind of thing I build.</p><p>A stage like this one, around your product, in your storefront. I handle the 3D asset side, the configurator logic, the phone experience, and all the quiet states that make it feel solid rather than fragile. You get something customers can actually use, not a showreel.</p><p><a href="https://contra.com/seacloud9/"><strong>contra.com/seacloud9</strong></a> — tell me what you sell.</p><p><em>This was genuinely fun to build, and honestly just as fun to share. If you end up playing with the colourways for longer than you meant to, that was the idea.</em></p><p><em>Built with AI assistance — I use AI throughout my process, for writing and for development. It drafts, I direct: I set the brief, made the design and asset calls, and checked the result with my own eyes before any of it shipped. It’s a genuinely good way to work, and it’s a big part of why a weekend was enough.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7588f2aba4ca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI, Your Computer: A Beginner’s Guide to Running LLMs Locally]]></title>
            <link>https://medium.com/@seacloud9/your-ai-your-computer-a-beginners-guide-to-running-llms-locally-db1f5baeb430?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/db1f5baeb430</guid>
            <category><![CDATA[llm-studio]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[localai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Tue, 15 Sep 2026 20:39:14 GMT</pubDate>
            <atom:updated>2026-09-15T20:39:14.554Z</atom:updated>
            <content:encoded><![CDATA[<h3>From your first offline conversation to the foundations of a useful local agent</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/1*w2s2vZg4NbYP8UGZnAYQww.png" /></figure><p>For many people, using artificial intelligence means opening a website, typing a question, and waiting for an answer. Occasionally, it also means arguing with the answer and asking the same question again with slightly more punctuation.</p><p>But the model does not have to live in a remote data center. You can download a language model and run it on your own computer.</p><p>Your laptop becomes the machine generating the response. Congratulations. Your kitchen table is now hosting a very small data center.</p><p>My recent work has taken that idea beyond a chat window. I have been building around a local Qwen model, agent instructions, review queues, and a dashboard that makes work visible. Those projects have taught me that getting a model to answer is the beginning. Making its answers useful takes a little more structure.</p><p>This article starts at that beginning. You do not need an agent framework, a publishing workflow, or a reason to leave Terminal open for three days. You need a compatible computer, a model that fits, and something small to try.</p><h3>What running locally actually means</h3><p>A large language model, or LLM, generates text using patterns learned during training. Its learned numerical values are called weights. Running a model means loading those weights and performing the calculations needed to produce a response.</p><p>With a hosted service, another computer does that work. With local inference, your computer does it. Inference is simply the name for using an already trained model.</p><p>You are not training a new model every time you open a conversation. You are using one that already exists.</p><p>The practical sequence is straightforward: download compatible model files, load them through an application, and start chatting. LM Studio’s <a href="https://lmstudio.ai/docs/app/basics">getting started guide</a> walks through that sequence and explains why access to the weights matters. Check the model’s license too. Downloadable weights do not automatically mean unrestricted use.</p><h3>Why I care about local models</h3><p>Control is a large part of the appeal. I can choose the model, inspect the surrounding workflow, and decide what information it receives.</p><p>There is also room to experiment without paying a hosted inference provider for every generated token. That does not make computing free. Storage, electricity, hardware, and your time still count. Anyone who has spent an evening comparing model downloads already understands that last expense.</p><p>Privacy is another useful reason, with an important condition: the whole workflow needs to stay local.</p><p>LM Studio documents offline support for downloaded models, document conversations, and its local server. Finding models, downloading them, and obtaining runtimes still require connectivity. See its <a href="https://lmstudio.ai/docs/app/offline">offline operation guide</a>.</p><p>A local model connected to a web search tool or an external service is part of a workflow that can send information elsewhere. Local inference describes where the model runs. It does not certify every tool around it.</p><p>For your first experiment, use fictional text and a plain local chat. There is plenty to learn before connecting anything else.</p><h3>Start with LM Studio</h3><p>For a beginner who wants a graphical interface, I would start with <a href="https://lmstudio.ai/">LM Studio</a>. Being able to browse, download, load, and talk to a model in one application makes the first session easier to understand.</p><p>Check the <a href="https://lmstudio.ai/docs/app/system-requirements">current system requirements</a> before downloading. LM Studio supports compatible Windows and Linux systems, while its Mac version requires Apple Silicon and macOS 14 or newer. Its documentation recommends at least 16 GB of RAM and notes that smaller models with modest context sizes may work on an 8 GB Mac. Intel Macs are not currently supported.</p><p>You do not need to buy a new computer to discover whether this interests you. Start by checking what your existing machine can support.</p><p>The first session looks like this:</p><ol><li>Install LM Studio from its official website.</li><li>Open Discover and choose a small, compatible model intended for chat or instruction following.</li><li>Review the model description, license, and download size.</li><li>Download it, then select it in the model loader in Chat.</li><li>Ask a simple question using information you can verify.</li></ol><p>These steps follow the <a href="https://lmstudio.ai/docs/app/basics">official setup guide</a>. Interface details can change, but the distinction between downloading and loading is useful: downloading stores the files; loading makes the model ready to run.</p><h3>Making sense of model names</h3><p>Soon you will encounter names such as Qwen, Llama, Gemma, and Mistral, followed by numbers and labels that look like someone dropped a keyboard into a filing cabinet.</p><p>You only need a few clues to begin.</p><p>Labels such as 7B or 14B commonly describe billions of parameters. More parameters generally require more storage and memory at the same numerical precision. They do not guarantee a better answer to your particular question.</p><p>Instruct or Chat usually indicates a model adapted to follow instructions or hold conversations. Coder suggests an emphasis on programming. Read the model description rather than treating any label as a promise.</p><p>For a first experiment, my suggestion is a small instruction model that fits comfortably in your available memory. If memory is limited, look at models with a few billion parameters before considering larger ones. The immediate goal is a responsive conversation you can evaluate.</p><p>A model that barely fits and makes the whole computer struggle is an awkward introduction to the subject.</p><h3>Quantization makes the files smaller</h3><p>Quantization represents model numbers with reduced precision, which can lower storage and memory requirements. Labels such as Q4 and Q8 commonly refer to families of quantized variants. The full label matters because quantization methods differ.</p><p>A version using roughly four bits per weight can be a practical starting experiment, provided the application supports it. Reduced precision can affect output quality, so smaller files are a tradeoff to evaluate.</p><p>For scale, seven billion weights at exactly four bits each would occupy about 3.5 GB in decimal units. That is arithmetic for the weights alone, not a promise that a particular model will run in 3.5 GB of RAM. Real files include additional information, and inference needs working memory too.</p><p>Your conversation consumes memory as well. The model’s context is the text it can work with at once, including instructions and conversation history. Larger context settings can increase memory use substantially. A long context capacity also does not guarantee that the model will use every detail correctly.</p><p>If loading fails or the machine becomes sluggish, try a smaller model and a shorter context setting. Leave memory for the operating system and your other applications.</p><h3>Where Ollama fits</h3><p><a href="https://docs.ollama.com/">Ollama</a> is another way to run models, and its command line and local service are useful when you want to connect a model to scripts or an application.</p><p>I find it helpful to choose based on the next task. A visual chat and model browsing workflow makes LM Studio approachable. A script calling a running model service makes Ollama worth exploring. Both can be part of a developer’s toolbox.</p><p>There is one detail beginners should check: Ollama also supports cloud models. An Ollama installation alone does not establish that inference happens on your machine. Choose a downloaded local model and consult the <a href="https://docs.ollama.com/faq">Ollama FAQ</a> for its local only mode if that is your goal.</p><p>Get one application working before comparing several. You will learn more from a completed experiment than from an impressive collection of installers.</p><h3>MLX, GGUF, and the layers underneath</h3><p>Mac users will encounter MLX fairly quickly. <a href="https://ml-explore.github.io/mlx/build/html/index.html">MLX</a> is a machine learning framework designed for Apple Silicon. Its unified memory model allows arrays to live in shared memory accessible to supported CPU and GPU operations.</p><p><a href="https://github.com/ml-explore/mlx-lm">MLX LM</a> builds on that framework for language model generation and fine tuning. It supports compatible models and quantized weights.</p><p>These names describe different layers:</p><ol><li>A model family, such as Qwen, identifies the learned model you want to use.</li><li>A file format, such as GGUF or Safetensors, describes how model data is stored.</li><li>A runtime or framework, such as llama.cpp or MLX, provides machinery for computation.</li><li>An application, such as LM Studio, helps you manage and interact with that machinery.</li></ol><p>MLX is not itself a file format equivalent to GGUF. When a download is described as an MLX model, that usually means the weights and configuration have been prepared for that ecosystem.</p><p>LM Studio supports compatible GGUF models through llama.cpp and MLX models on Apple Silicon, as described on its <a href="https://lmstudio.ai/">official site</a>. That makes it possible to explore both without building your own interface.</p><p>On your first day, choose a supported download and get a response. Comparing runtimes can wait until you have a task worth comparing them on.</p><h3>Give your first model a fair test</h3><p>Open a fresh local chat and paste this fictional exercise:</p><pre>Use only the note below. Summarize it in two sentences.<br>Then say whether the note tells us the repair cost.<br>If it does not, say that the cost is unknown.</pre><pre>Fictional note:<br>CheckEngineSal recorded an oil change on a demo vehicle<br>at 42,000 miles. The next inspection is planned for October.<br>No invoice is included.</pre><p>This is small enough to judge yourself. Did the model preserve the mileage? Did it describe the inspection as planned? Did it invent a price?</p><p>Then remove the mileage and ask the same question again. Watch whether the model respects missing information or fills the gap with something plausible.</p><p>Once the model and required runtime are downloaded, you can disconnect from the network and repeat the plain chat exercise. A successful response demonstrates that this particular interaction works offline. It does not prove that every connected feature will behave the same way.</p><p>The <a href="https://medium.com/example/README.md">local experiment worksheet</a> provides these prompts and a place to record your observations. They are manual exercises, not benchmark results. I have not measured model speed or accuracy for this article.</p><h3>What changed when I started building agents</h3><p>My Qwen and OpenClaw work made the surrounding software much more interesting to me.</p><p>A model can propose a draft. An agent runtime can provide instructions and controlled access to tools. Ordinary application code can check required fields, preserve revisions, and keep a draft waiting for review. A scheduler can start a configured job. A human decides whether the proposed action should happen.</p><p>Those are separate responsibilities. Fluent text does not tell you whether a source supports the claim or whether the owner approved publication.</p><p>The <a href="https://medium.com/openclaw-agent-creation/">agent creation companion</a> demonstrates that boundary with a fictional source packet and a local validator. The validator checks structure and routing. It does not run Qwen or establish factual accuracy.</p><p>The <a href="https://medium.com/dashboad-open-claw1/">first dashboard article</a> explores the review queue. The <a href="https://medium.com/dashboad-open-claw2/">second article</a> expands that idea into a view of several kinds of work. Its <a href="https://medium.com/dashboad-open-claw2/article/blog-assets/04-fictional-command-center.png">fictional command center screenshot</a> illustrates the interface; its synthetic counts and statuses are not live operational evidence or a local inference benchmark.</p><p>These are the foundations I want beginners to see behind the dashboard. Downloading a model gives you a text generator. A useful workflow also needs clear inputs, visible failure states, and permission boundaries enforced by software. Instructions alone are not access control.</p><h3>Build a toolbox one useful task at a time</h3><p>I see local and hosted models as parts of the same toolbox. Which one belongs in a workflow depends on the task, privacy requirements, hardware, cost, and the quality you can actually verify.</p><p>You do not need to settle that question for every future project today.</p><p>Start with one model and one small task. Ask it to summarize a fictional note. Check whether it kept the facts straight. Try it offline. Save what you learned.</p><p>Later, you can compare another model, connect a local application, or give an agent a carefully bounded job. Each step becomes easier when the previous one is understood.</p><p>The satisfying moment is still the first one: the network is disconnected, you ask a question, and your own computer answers.</p><p>You can decide whether to call the kitchen table a compute cluster after that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db1f5baeb430" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Gave My Local LLM a Job Description. It Still Needed a Manager.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@seacloud9/i-gave-my-local-llm-a-job-description-it-still-needed-a-manager-7aeb32fabe6e?source=rss-dcf3b2ca8a97------2"><img src="https://cdn-images-1.medium.com/max/686/1*YSyUkzadHe0XxtQbU_1dew.jpeg" width="686"></a></p><p class="medium-feed-snippet">Creating a useful OpenClaw agent with Qwen, a clear role, and a deliberately boring safety boundary</p><p class="medium-feed-link"><a href="https://medium.com/@seacloud9/i-gave-my-local-llm-a-job-description-it-still-needed-a-manager-7aeb32fabe6e?source=rss-dcf3b2ca8a97------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@seacloud9/i-gave-my-local-llm-a-job-description-it-still-needed-a-manager-7aeb32fabe6e?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/7aeb32fabe6e</guid>
            <category><![CDATA[qwen]]></category>
            <category><![CDATA[openclaw]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Tue, 08 Sep 2026 15:42:51 GMT</pubDate>
            <atom:updated>2026-09-08T15:42:51.235Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[From One Queue to a Local Command Center: Building an OpenClaw + Qwen Dashboard]]></title>
            <link>https://medium.com/@seacloud9/from-one-queue-to-a-local-command-center-building-an-openclaw-qwen-dashboard-cdc653920f08?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/cdc653920f08</guid>
            <category><![CDATA[qwen]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[localai]]></category>
            <category><![CDATA[openclaw]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Sun, 06 Sep 2026 23:49:48 GMT</pubDate>
            <atom:updated>2026-09-06T23:49:48.714Z</atom:updated>
            <content:encoded><![CDATA[<h3>Part 2: Giving local agents useful jobs, clear handoffs, and somewhere to put the paperwork</h3><h4>Part 1:<a href="https://medium.com/@seacloud9/from-zero-to-one-open-claw-concierge-i-turned-a-local-qwen-agent-into-a-human-gated-publishing-d0c5128beeb8">From One Queue to a Local Command Center: Building an OpenClaw + Qwen Dashboard</a></h4><p>In Part 1, I built a local publishing workflow around Qwen and OpenClaw. A model could draft something, a person could inspect it, and an approval referred to the exact text being reviewed.</p><p>Then I added more jobs.</p><p>A second persona needed its own queue. Several websites needed checks. Analytics needed somewhere to report. Overnight tasks needed a schedule. Before long, I was checking enough JSON files to qualify for a modest administrative position.</p><p>The dashboard grew out of that problem. I wanted one place to see what the agents had prepared, what had passed its checks, and what still needed my attention.</p><p>The architecture comes from the project we are building. The walkthrough uses fictional personas and illustrative records. CheckEngineSal is our automotive example. PixelArchivist handles the gaming examples. These are teaching names, not references to anyone’s social accounts.</p><h3>What the agents actually automate</h3><p>Imagine a small automotive reference site. Each morning, someone checks source material, selects useful topics, writes short posts, verifies the supporting claims, and puts the results in a review queue.</p><p>An agent can take on the reading and drafting portions. A script can check required fields, enforce the destination, and write a receipt. A scheduler can start that work at an agreed time. The dashboard can collect the results into a view the owner can review over coffee.</p><p>The intended flow looks like this:</p><pre>Source material<br>↓<br>Agent selects a topic and drafts a post<br>↓<br>Validation checks the record and its evidence<br>↓<br>The draft enters the correct review queue<br>↓<br>The owner reviews the proposed action<br>↓<br>An authorized dispatcher can act and record the outcome</pre><p>Qwen supplies the language model. OpenClaw provides the agent runtime and workspace context. Our application code supplies the queue rules, validation, and reporting.</p><p>That division makes the automation easier to understand. Generating a useful paragraph is a language task. Comparing two account destinations is a rule. I do not need a model to have an opinion about whether two strings match.</p><p>This is the workflow we are developing toward. Parts already exist locally, including specialist queues and dashboard projections. Other parts, particularly unattended repository execution and external messaging, still need their operational wiring completed.</p><h3>CheckEngineSal gets a desk</h3><p>For our fictional automotive agent, the job is deliberately specific: prepare short, sourced drafts about vehicle ownership for a human editor.</p><p>Sal can read reviewed material, identify a useful angle, and draft a post in a practical voice. He should be comfortable saying that a detail needs verification. A confident guess about a recall is still a guess, even if it arrives wearing coveralls.</p><p>PixelArchivist has a different assignment and a different voice. The two agents may use the same local model service while receiving different instructions and context.</p><p>The dashboard brings their work together for review. Their destinations remain distinct.</p><pre>{<br>  &quot;persona&quot;: &quot;automotive&quot;,<br>  &quot;channel&quot;: &quot;demo&quot;,<br>  &quot;targetAccount&quot;: &quot;CheckEngineSal&quot;,<br>  &quot;status&quot;: &quot;VALIDATED&quot;<br>}</pre><p>In this example, the destination is a fictional label. A deployed service would resolve its own reviewed account configuration separately.</p><p>The label belongs in the proposed payload because the destination is part of the editorial decision. An automotive post turning up in a gaming feed is a routing defect, even if the engine does sound like an arcade cabinet.</p><h3>A shared view without shared confusion</h3><p>The content view combines drafts from several specialists. Each record shows the authoring persona, intended destination, text, evidence, validation result, and review state.</p><p>That answers the questions I actually have when opening the dashboard:</p><ol><li>Who prepared this?</li><li>What is the proposed post?</li><li>Where would it go?</li><li>What supports it?</li><li>What decision does it need from me?</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*UTU7_9kUuxnTrv2x.png" /></figure><p>Figure 1: A browser capture of the companion demo. All names, counts, drafts, and job results are illustrative. This image demonstrates the layout and is not a live operations report.</p><p>The projection gives the dashboard a limited view of the underlying system. It contains the information needed for review, while provider credentials stay elsewhere.</p><p>The application may expose specific local review actions. Those actions still need to check the current source record and the exact payload. A pleasant interface does not remove the need for those checks. It just makes the paperwork less hostile.</p><h3>A schedule needs an actual runner</h3><p>A schedule card is useful for planning. To automate the work, something must also launch the command, apply a timeout, collect the result, and make it available to the next task.</p><p>For a hypothetical daily workflow, I might plan:</p><ol><li>At 00:05, validate the automotive source pages.</li><li>At 01:15, validate motorcycle material.</li><li>After both feeds pass, ask CheckEngineSal to prepare review drafts.</li><li>Refresh the dashboard after those drafts are written.</li><li>At 04:00, collect analytics.</li><li>At 05:00, allow a longer catalog task up to four hours.</li></ol><p>Dependencies need enforcement, not just a convenient arrangement of clock times. If a feed fails, the drafting task should record that it could not proceed with fresh material. If analytics overruns, a task that shares its execution lock should wait or be skipped according to an explicit rule.</p><p>A long catalog build deserves a realistic time allowance. It also deserves progress logs and a timeout that stops its child processes. “It takes a while” is useful context, but a difficult status to put on a dashboard.</p><p>In our project, a four hour slot was added to the plan for the long build. That change described the intended budget. It did not install a runner or demonstrate a successful overnight run.</p><h3>Receipts tell us what happened</h3><p>A receipt records the outcome of a particular operation. The scope of that operation matters.</p><p>During development, we saw a wrapper finish successfully while the analytics report recorded failed collection. The dashboard had refreshed, but the site metrics were unavailable.</p><p>That exposed a reporting weakness. A single COMPLETE label could sound broader than the work it actually proved.</p><p>For a future receipt, I would separate the stages explicitly:</p><pre>{<br>  &quot;task&quot;: &quot;dailyAnalyticsDemo&quot;,<br>  &quot;runnerStatus&quot;: &quot;COMPLETE&quot;,<br>  &quot;collectionStatus&quot;: &quot;FAILED&quot;,<br>  &quot;dashboardRefreshStatus&quot;: &quot;COMPLETE&quot;,<br>  &quot;traffic&quot;: null<br>}</pre><p>This is an illustrative receipt design, not a claim that the current runner already emits these fields.</p><p>A reader can now tell that the process finished but did not retrieve traffic data. Unknown traffic stays unknown. Replacing it with zero would create a very dramatic graph for a problem that might only require logging in.</p><p>The same idea applies to content. A validation receipt can show that existing pages passed checks. It cannot establish that fresh material was scraped or that a post was published.</p><h3>A rebuild can succeed without creating a new page</h3><p>One lesson from the repository work was that page growth and build success answer different questions.</p><p>A generator can refresh existing pages and finish with the same file count. That may be a valid maintenance result. A collection task whose purpose is to discover new records needs a different measure.</p><p>For a hypothetical maintenance task, I would check completion, output integrity, and expected files. For an ingestion task, I would also record source freshness and newly discovered records.</p><p>The current strict growth gate is an implementation choice that needs that distinction. Counting pages is useful. Treating every unchanged count as a broken build is less useful.</p><p>Likewise, a process returning zero does not establish that every optional check passed. If a link test was skipped because a dependency was missing, the receipt should say so.</p><p>These details are what turn an overnight job into work you can trust in the morning.</p><h3>Messaging becomes another place to review work</h3><p>WhatsApp and Discord are appealing because they could bring an alert to the owner without requiring the dashboard to stay open all day.</p><p>In our example, Sal might prepare a handoff saying that a batch needs review. The owner could request status or reject a proposal. The message would refer to a particular task or payload.</p><p>The local WhatsApp work includes a broker, bridge, setup flow, and preflight checks. Provider activation still requires its own setup and delivery tests. The Discord work currently consists of a configuration contract and setup guidance.</p><p>Those are different levels of progress. Calling both of them “connected” would save space and lose useful information.</p><p>A remote reply also needs a defined meaning. Recording an approval is one operation. Executing a public action is another operation with its own credentials and outcome.</p><p>Sal can have a personality. He does not need every key on the ring.</p><h3>Try the small companion example</h3><p>The companion code uses two fictional personas and three synthetic drafts. Two drafts are marked eligible for review. The third is still a draft.</p><p>Run these commands from the example folder:</p><pre>node command-center.mjs route<br>node command-center.mjs run-validation<br>node command-center.mjs status</pre><p>Routing adds eligible records to a local queue. Repeating it should not duplicate the same records. The fixture checks confirm the supported persona, destination, text, and state.</p><p>These are structural checks against synthetic inputs. They do not fact check automotive claims, invoke Qwen, run an OpenClaw agent, install a schedule, or publish anything.</p><p>That narrow example lets readers inspect the handoff without setting up the full stack. The larger system would replace the fixture producer with an agent invocation and keep the deterministic checks around its output.</p><p>The <a href="https://github.com/seacloud9/blog_examples/blob/main/dashboad-open-claw2/example/README.md">example guide</a> explains the commands and reset behavior.</p><h3>Where agent creation fits</h3><p>The dashboard is downstream of a more interesting design question: how do you give a model a useful job?</p><p>For CheckEngineSal, that means defining the task, writing a voice guide, selecting source material, limiting tools, and agreeing on an output contract. OpenClaw supplies the runtime in which those pieces come together. A local LLM supplies the language work.</p><p>That deserves its own article, so I have written a companion: <a href="https://github.com/seacloud9/blog_examples/blob/main/openclaw-agent-creation/article/Giving%20a%20Local%20LLM%20a%20Job%20Description.md">I Gave My Local LLM a Job Description. It Still Needed a Manager.</a></p><p>It walks through a theoretical automotive agent, from its workspace files to a first test task. The goal is a useful colleague with a clear assignment. The coffee budget remains reassuringly small.</p><h3>What comes next</h3><p>The next steps are concrete: complete the repository runners, distinguish collection failures from wrapper success, connect validated source records to draft generation, and test messaging with real provider configuration.</p><p>As those pieces come online, the dashboard can show their receipts and review queues. The payoff is less repetitive preparation and a clearer view of where human judgment is still needed.</p><p>That is the version of automation I want on my desk. Useful work happens in the background, and when I open the dashboard, I can understand what happened.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cdc653920f08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Zero to One Open Claw Concierge: I Turned a Local Qwen Agent Into a Human-Gated Publishing…]]></title>
            <link>https://medium.com/@seacloud9/from-zero-to-one-open-claw-concierge-i-turned-a-local-qwen-agent-into-a-human-gated-publishing-d0c5128beeb8?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0c5128beeb8</guid>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[openclaw]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Wed, 02 Sep 2026 04:00:19 GMT</pubDate>
            <atom:updated>2026-09-02T04:00:19.932Z</atom:updated>
            <content:encoded><![CDATA[<h3>From Zero to One Open Claw Concierge: I Turned a Local Qwen Agent Into a Human-Gated Publishing System</h3><h3>The difficult part was not generating a tweet. It was building a trustworthy path from an idea to a public action.</h3><p>It takes about five minutes to make a language model write a tweet.</p><p>It takes considerably longer to build a system you would trust with the <strong>Publish</strong> button.</p><p>That distinction became the center of a local AI experiment I have been building around Qwen, OpenClaw, <a href="https://nova64.io/">Nova64</a>, and <a href="https://starcade9.io/">Starcade9</a>. The original goal sounded simple: give a locally running model a brand persona, connect it to X, and let it help create promotional content.</p><p>The first draft was easy. The zero-to-one leap came later.</p><p>The “zero” was a model producing plausible text in a terminal. The “one” was an authenticated local command center where every draft could be inspected, validated, hashed, approved, rejected, expired, audited, and — eventually — handed to a separate publisher without ever giving the model direct control of a public account.</p><p>This article is the story of that transition.</p><blockquote><em>The useful unit of AI automation is not a clever generation. It is a controlled state transition.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8CfecLrnqcZzQcJf" /></figure><p><em>Figure 1 — The local command center. This article’s screenshots were captured from a synthetic local copy of the queue; no X credentials or live publishing actions were used.</em></p><h3>The project before the dashboard</h3><p>The underlying system already had several useful pieces:</p><ul><li>Qwen running locally on Apple silicon.</li><li>OpenClaw organizing agents, workspace instructions, memory, and tools.</li><li>An ARCA/9 persona for the Nova64 and Starcade9 world.</li><li>A local X integration.</li><li>Structured drafts with source references and validation metadata.</li><li>A rule that external actions required human approval.</li></ul><p>That was enough to prove the components could communicate. It was not enough to make the workflow comfortable — or safe — to operate every day.</p><p>The approval state lived in JSON files. Agent output had to be inspected manually. The difference between “validated,” “approved,” and “published” was technically present but not visually obvious. Credential boundaries existed as ideas, not yet as a product surface.</p><p>In other words, the system had capability but not leverage.</p><p>The dashboard became the missing control plane.</p><h3>Start with the invariant, not the interface</h3><p>Before writing a page component, I wrote down the rule the application could never violate:</p><pre>Generation != validation<br>Validation != approval<br>Approval != execution<br>Execution != verified outcome</pre><p>This single separation shaped the rest of the architecture.</p><p>An agent may generate a draft. Deterministic checks decide whether the record is structurally valid. A human may approve the exact payload. A separate dispatcher may eventually execute it. Only an external receipt can prove publication occurred.</p><p>Each arrow is a boundary, not a stylistic distinction.</p><pre>Qwen / OpenClaw agent<br>        |<br>        v<br>Validated content queue<br>        |<br>        v<br>Exact-payload approval queue<br>        |<br>        v<br>Approved dispatcher handoff<br>        |<br>        v<br>Isolated credential broker<br>        |<br>        v<br>X API + sanitized receipt</pre><p>The dashboard currently implements the first three stages. The broker and live dispatcher remain locked until their own security tests pass.</p><p>That is intentional. A half-built publishing integration should fail closed, not become accidentally autonomous.</p><h3>Step 1: Make model output inspectable</h3><p>The first useful dashboard screen was not a chat window. It was a content queue.</p><p>Each item carries more than text:</p><pre>{<br>  &quot;id&quot;: &quot;CONTENT-ARCA9-...&quot;,<br>  &quot;persona&quot;: &quot;arcade&quot;,<br>  &quot;channel&quot;: &quot;x&quot;,<br>  &quot;status&quot;: &quot;VALIDATED&quot;,<br>  &quot;text&quot;: &quot;Exact proposed post text&quot;,<br>  &quot;canonicalUrl&quot;: &quot;https://nova64.io&quot;,<br>  &quot;claims&quot;: [<br>    {<br>      &quot;classification&quot;: &quot;fiction&quot;,<br>      &quot;source&quot;: null<br>    }<br>  ],<br>  &quot;sources&quot;: [&quot;/shared/persona-arcade.md&quot;],<br>  &quot;validation&quot;: {<br>    &quot;passed&quot;: true,<br>    &quot;errors&quot;: []<br>  }<br>}</pre><p>The interface exposes the things that matter during review:</p><ul><li>exact text and character count;</li><li>brand route;</li><li>destination URL;</li><li>content pillar;</li><li>claim classification;</li><li>media-rights state;</li><li>evidence references;</li><li>deterministic validation results;</li><li>current approval state.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bPT_r5JnLYdp5fcs" /></figure><p><em>Figure 2 — The Content Queue makes agent output legible as records rather than chat messages.</em></p><p>This changed how I thought about the model. Qwen was no longer “the application.” It was a proposal engine feeding a typed workflow.</p><p>That framing also made failure easier to handle.</p><h3>The most valuable result was a failed generation</h3><p>The first realistic ARCA/9 batch looked good at a glance. Independent validation found several problems:</p><ul><li>one draft exceeded the character limit;</li><li>some source identifiers did not exist;</li><li>a few details sounded historical but had been invented;</li><li>some promotional wording implied product availability that had not been verified;</li><li>one repair attempt returned the wrong JSON envelope.</li></ul><p>None of those drafts reached X.</p><p>This is the practical reason deterministic gates matter. A model can say it followed instructions while still producing a structurally invalid or factually unsupported record. Narrative confidence is not evidence.</p><p>The rejected output was replaced with a reviewed batch:</p><ul><li>four Nova64 creative concepts;</li><li>two carefully bounded Starcade9 promotional signals;</li><li>two non-promotional ARCA/9 posts.</li></ul><p>Every record stayed below the configured character limit, followed the correct brand-link convention, and used only recognized evidence sources.</p><p>The lesson is not that local models are unreliable and cloud models are reliable. The lesson is that <strong>all generative output becomes more useful when it must pass deterministic contracts</strong>.</p><h3>Step 2: Turn a draft into an immutable proposal</h3><p>Clicking “Send to publish review” does not publish anything. It creates a new approval record containing the exact action and payload under review.</p><p>The approval includes:</p><ul><li>immutable approval ID;</li><li>content ID;</li><li>destination (x-publishing);</li><li>exact post text;</li><li>canonical URL and media path;</li><li>SHA-256 payload hash;</li><li>version number;</li><li>request time;</li><li>expiration time;</li><li>evidence sources;</li><li>risk classification;</li><li>nullable approval, rejection, and outcome fields.</li></ul><p>The hash is calculated from a stable serialization of the exact payload. Object keys are sorted recursively before hashing so equivalent objects produce the same digest.</p><p>Conceptually:</p><pre>function payloadSha256(payload: PublishPayload) {<br>  const stable = recursivelySortObjectKeys(payload);<br>  return sha256(JSON.stringify(stable));<br>}</pre><p>When the owner submits a decision, the server reloads the queue and source content under a lock, then checks:</p><ol><li>The record still exists.</li><li>Its status is still PENDING.</li><li>The submitted version is current.</li><li>The approval has not expired.</li><li>The stored payload still matches its SHA-256 hash.</li><li>The source draft still produces the same hash.</li><li>The local session, origin, host, and CSRF token are valid.</li><li>The owner explicitly confirmed the exact displayed payload.</li></ol><p>Only then can PENDING become APPROVED.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VVO4AuWymkfY70Dw" /></figure><p><em>Figure 3 — An approval is a decision about this exact payload, not a general permission to post something similar later.</em></p><p>This defeats an important class of workflow bugs: approval of revision A cannot silently authorize revision B.</p><h3>Step 3: Treat Server Actions like public endpoints</h3><p>The interface uses Next.js App Router and server-side forms. That made Server Actions a natural fit for queue mutations, but “server-side” does not automatically mean “trusted.”</p><p>Next.js explicitly recommends authenticating and authorizing every Server Function because it can be reached through a direct POST request, not only through the button in your UI. Its forms also support progressive enhancement, which let this dashboard stay largely server-rendered without inventing a client-side state layer. See the official <a href="https://nextjs.org/docs/app/getting-started/mutating-data">Next.js guide to mutating data</a> and <a href="https://nextjs.org/docs/app/guides/authentication">authentication guidance</a>.</p><p>The local mutation path therefore requires:</p><ul><li>a valid derived session cookie;</li><li>loopback host validation;</li><li>exact same-origin validation;</li><li>a session-bound HMAC CSRF token;</li><li>bounded form inputs;</li><li>fixed IDs rather than client-supplied file paths;</li><li>server-side state and hash revalidation.</li></ul><p>The <a href="https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html">OWASP CSRF Prevention Cheat Sheet</a> recommends tokens on state-changing requests, origin verification, non-GET mutations, SameSite cookies, and user-interaction defenses for sensitive operations. The local dashboard combines those layers rather than assuming 127.0.0.1 is a security feature by itself.</p><p>The login produces a derived, 12-hour, HTTP-only, SameSite=Strict cookie. The raw dashboard password is never stored in browser storage or passed to screenshot automation.</p><h3>Step 4: Make file-backed state behave like a transaction</h3><p>For a single-user local tool, a small JSON queue is easier to inspect and back up than a database. That simplicity does not excuse unsafe writes.</p><p>The transaction service uses:</p><ul><li>an exclusive lock file;</li><li>a bounded lock timeout;</li><li>stale-lock recovery;</li><li>validation before and after lock acquisition;</li><li>a temporary file created in the destination directory;</li><li>atomic rename over the previous queue;</li><li>owner-only file permissions;</li><li>an append-only, redacted JSONL audit event.</li></ul><p>The desired crash behavior is simple: the filesystem contains either the old valid queue or the new valid queue — never half of a JSON document.</p><p>The state machine is deliberately small:</p><p>FromToWho may perform it?External action?Validated contentPENDING approvalAuthenticated local ownerNoPENDINGAPPROVEDAuthenticated local ownerNoPENDINGREJECTEDAuthenticated local ownerNoAPPROVEDEXECUTED or FAILEDFuture isolated dispatcher onlyYes</p><p>The dashboard cannot set EXECUTED. That state belongs to the component that can obtain an external receipt.</p><h3>Step 5: Give the dashboard less power than the system</h3><p>The local dashboard runs in its own container on 127.0.0.1:18791.</p><p>Its root filesystem is read-only. Linux capabilities are dropped. no-new-privileges is enabled. CPU, memory, and process counts are bounded. Docker documents the Compose controls for <a href="https://docs.docker.com/reference/compose-file/services/">read_only, </a><a href="https://docs.docker.com/reference/compose-file/services/">cap_drop, security options, and volume access</a>.</p><p>Most importantly, the service receives only four reviewed mounts:</p><pre>volumes:<br>  - ./concierge/dashboard-data:/data/dashboard:ro<br>  - ./concierge/supervisor/approvals:/data/approvals<br>  - ./concierge/supervisor/audit:/data/audit<br>  - ./concierge/arcade/drafts:/data/content:ro</pre><p>It does <strong>not</strong> receive:</p><ul><li>the Docker socket;</li><li>the OpenClaw state directory;</li><li>repository write access;</li><li>raw private documents;</li><li>X credentials;</li><li>a generic HTTP client;</li><li>a publishing SDK;</li><li>the future dispatcher.</li></ul><p>That is the key security design: compromising the dashboard should not automatically expose the credentials required to publish.</p><h3>Step 6: Keep approval separate from dispatch</h3><p>After an owner approves a post, the item moves into a “Ready for dispatcher” section.</p><p>It still cannot leave the Mac.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*jnOidRcWoLdcOUg3" /></figure><p><em>Figure 4 — Approval is recorded locally. The interface continues to state that the X broker is locked.</em></p><p>The eventual publisher will be a separate loopback-only broker. It should expose narrow operations such as:</p><pre>verifyIdentity(connectionId)<br>publishApprovedPost(approvalId, payloadHash)<br>connectionStatus(connectionId)</pre><p>It should not expose a generic URL, HTTP method, request body, shell command, or credential export function.</p><p>The dispatcher will receive only an approval ID and payload hash. The broker will reload the current approval, recompute the payload, confirm the approved state, verify account identity and scope, publish, and return a sanitized receipt.</p><p>X’s official OAuth documentation requires exact redirect-URI matching for OAuth 2.0 Authorization Code Flow with PKCE and explains the roles of state, code_challenge, access tokens, and refresh tokens. That flow belongs at the credential broker—not inside Qwen and not inside the browser dashboard. See the <a href="https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code">X OAuth 2.0 PKCE guide</a> and <a href="https://docs.x.com/fundamentals/authentication/guides/authentication-best-practices">authentication best practices</a>.</p><p>If a credential has appeared in chat, terminal history, logs, screenshots, or a repository, rotate it before connecting the broker. A local system still produces history and backups. “Local” is a deployment property, not permission to be casual with secrets.</p><h3>Step 7: Test behavior, not screenshots</h3><p>The polished interface matters because it makes decisions easier. It is not proof that the workflow is correct.</p><p>The acceptance suite exercises:</p><ul><li>idempotent staging;</li><li>batch staging without batch approval;</li><li>exact confirmation requirements;</li><li>successful approval;</li><li>rejection with a reason;</li><li>stale-version failure;</li><li>changed-source failure;</li><li>expired-approval failure;</li><li>payload hash mismatch failure;</li><li>lock behavior;</li><li>audit redaction;</li><li>unauthenticated redirects;</li><li>production builds;</li><li>container health;</li><li>phone-width layout;</li><li>browser console and framework-overlay checks;</li><li>accessibility auditing.</li></ul><p>The browser tests use a synthetic password and copied queue files. Approval and rejection can therefore be clicked end to end without touching the live queue or X.</p><p><em>Figure 5 — The review flow at 390 pixels wide.</em></p><p>One test deserves special emphasis: after local approval, the expected external-publication count remains zero.</p><p>That is not an incomplete test. It is the expected result of the current phase.</p><h3>What made this a zero-to-one build</h3><p>The visible result is a dashboard. The deeper result is a new operational primitive.</p><p>Before this work, I could ask a model for a post.</p><p>After this work, I can move a proposal through a process with identity, evidence, validation, review, expiration, immutable intent, audit history, and a deliberately absent execution capability.</p><p>That process can eventually support more than X:</p><ul><li>job applications;</li><li>client proposals;</li><li>product announcements;</li><li>repository deployments;</li><li>scheduled content;</li><li>purchases;</li><li>any external action where “the model suggested it” is not sufficient authorization.</li></ul><p>The generative model is replaceable. The approval contract is durable.</p><p>That is why I think local AI becomes most interesting when it stops being a demo and starts becoming infrastructure. Not because the agent is allowed to do everything, but because the system makes it easy to grant exactly one narrow permission at the right time.</p><h3>What I would build next</h3><p>The next phase is not “turn on autonomous posting.” It is to complete the smallest safe external loop:</p><ol><li>Rotate any previously exposed X credentials.</li><li>Add a non-echoing setup flow backed by macOS Keychain or an owner-only secret store.</li><li>Build the isolated loopback credential broker.</li><li>Verify the connected X identity and least-privilege scopes.</li><li>Add a dispatcher that accepts only approved IDs and matching hashes.</li><li>Record the X post ID and URL as a sanitized outcome.</li><li>Test revocation, retry, wrong-account, changed-payload, and restart cases.</li></ol><p>Only then does the final transition become available:</p><pre>APPROVED -&gt; EXECUTED</pre><p>The same principle will continue to apply: the interface can make the action pleasant, but only the receipt can make it true.</p><p><a href="https://github.com/seacloud9/blog_examples/tree/main/dashboad-open-claw1">Github Repo</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0c5128beeb8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your Mac mini Can Be a Team: Building Custom Local AI Agents with Qwen, MLX, and Better System…]]></title>
            <link>https://medium.com/@seacloud9/your-mac-mini-can-be-a-team-building-custom-local-ai-agents-with-qwen-mlx-and-better-system-4d9725194331?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d9725194331</guid>
            <category><![CDATA[system-prompt]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[m4-mac-mini]]></category>
            <category><![CDATA[qwen]]></category>
            <category><![CDATA[local-llm]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 16:59:21 GMT</pubDate>
            <atom:updated>2026-08-31T16:59:21.718Z</atom:updated>
            <content:encoded><![CDATA[<h3>Your Mac mini Can Be a Team: Building Custom Local AI Agents with Qwen, MLX, and Better System Prompts</h3><h3>Your Mac mini Can Be a Team: Building Custom Local AI Agents with Qwen, MLX, and Better System Prompts</h3><h3>How I turned one locally running model into a Creative Technologist, Software Engineer, Technical Project Manager, and fictional arcade intelligence without fine-tuning or sending prompts to the cloud</h3><p>There is a moment in almost every local-AI experiment when the novelty wears off.</p><p>The model is running. The chat window works. You ask it a few questions, watch Activity Monitor, enjoy the fact that the answer came from a machine sitting on your desk — and then wonder:</p><p><strong>What makes this meaningfully mine?</strong></p><p>For me, the answer was not another benchmark or a larger model. It was customization.</p><p>I wanted one local model that could change its working behavior depending on the job:</p><ul><li>a Creative Technologist that thinks visually and understands real-time graphics;</li><li>a Software Engineer that values correctness, tests, and maintainable architecture;</li><li>a Technical Project Manager that exposes risks, dependencies, and missing decisions;</li><li>a fictional arcade archivist with a voice recognizable enough to feel like a character.</li></ul><p>All four run on the same Qwen model. There are no duplicated weights and no fine-tuned checkpoints. Each agent is a lightweight composition of:</p><pre>base model<br>    + role system prompt<br>    + task mode<br>    + sampling profile<br>    + conversation history<br>    = specialized local agent</pre><p>That architecture is simple enough to understand completely, yet useful enough to become a daily workstation.</p><p>This article walks through the whole build: choosing hardware, serving Qwen with MLX, adding a private web interface, keeping the services stable, writing system prompts that affect behavior instead of merely adding flavor, composing reusable agents, and testing whether the customization actually works.</p><blockquote><strong><em>Tested workstation:</em></strong><em> an M4 Pro Mac mini with 48 GB of unified memory, MLX 0.32.0, MLX LM 0.31.3, Open WebUI 0.11.1, and </em><em>mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ. You can follow the same design with a smaller Qwen model on a lower-memory Mac.</em></blockquote><h3>Why a Mac mini makes an unusually good local-AI appliance</h3><p>The Mac mini is not the cheapest way to maximize raw tokens per second. It is compelling for a different combination of reasons:</p><ul><li>Apple silicon gives the CPU and GPU access to a unified memory pool.</li><li>MLX is designed specifically for Apple silicon.</li><li>The machine is small, quiet, and power-efficient enough to leave running.</li><li>macOS has familiar tools for persistent user services.</li><li>A local OpenAI-compatible endpoint can serve command-line clients, browser interfaces, scripts, and developer tools at the same time.</li></ul><p>Unified memory is the important phrase. A discrete GPU workstation might have plenty of system RAM but only a smaller pool of VRAM available to inference. On Apple silicon, the model and its runtime data share the larger unified pool.</p><p>That does not make memory unlimited.</p><p>A model’s downloaded file size is only part of the requirement. Inference also needs runtime overhead, temporary allocations, and a key/value cache that grows with context. Long conversations and repeated cached prompts can use far more memory than a one-line smoke test suggests.</p><p>For this build, 48 GB provides practical headroom for the six-bit Qwen3–30B-A3B conversion, the operating system, a browser UI, and development tools. If your Mac has less memory, begin with a smaller or more aggressively quantized model. A responsive 8B or 14B model is more useful than a 30B model that pushes the machine into constant memory pressure.</p><p>The correct model is the one your actual workload can run repeatedly — not the largest file you can load once.</p><h3>Why Qwen3–30B-A3B and MLX work well together</h3><p>Qwen’s original <a href="https://qwenlm.github.io/blog/qwen3/">Qwen3 announcement</a> describes Qwen3–30B-A3B as a mixture-of-experts model with roughly 30 billion total parameters and about 3 billion activated for each token. It also lists MLX among the recommended tools for local use.</p><p>Mixture of experts is attractive for a workstation because the model has a large total parameter pool without activating all of it for every token. Quantization reduces the storage and memory cost further. The exact <a href="https://huggingface.co/mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ">six-bit MLX conversion used here</a> can be loaded directly from the Hugging Face Hub.</p><p><a href="https://github.com/ml-explore/mlx-lm">MLX LM</a> provides the rest of the local stack:</p><ul><li>model download and loading;</li><li>Apple-silicon inference;</li><li>text generation and chat commands;</li><li>quantization tools;</li><li>an OpenAI-compatible HTTP server.</li></ul><p>That last feature is the architectural hinge. Once Qwen appears at a familiar /v1/chat/completions endpoint, the model stops being tied to one interface. Any compatible local client can use it.</p><h3>Part 1: Install the local model runtime</h3><p>Use a dedicated Python environment. Local-AI packages move quickly, and isolating them prevents an unrelated Python upgrade from breaking the workstation.</p><pre>mkdir -p &quot;$HOME/local-llm&quot;/{bin,logs,pids,personas}</pre><pre>python3.11 -m venv &quot;$HOME/mlx-qwen&quot;<br>source &quot;$HOME/mlx-qwen/bin/activate&quot;</pre><pre>python -m pip install --upgrade pip<br>python -m pip install mlx-lm</pre><p>Check the installed versions:</p><pre>python -m pip show mlx mlx-lm</pre><p>For a reproducible workstation, record known-good versions after testing:</p><pre>python -m pip freeze &gt; &quot;$HOME/local-llm/requirements.lock.txt&quot;</pre><p>Do not assume that blindly upgrading every package will improve a working system. Save the version set, read release notes, and keep a rollback path.</p><h3>Start Qwen as a local HTTP service</h3><pre>source &quot;$HOME/mlx-qwen/bin/activate&quot;</pre><pre>mlx_lm.server \<br>  --model mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ \<br>  --host 127.0.0.1 \<br>  --port 8080 \<br>  --prompt-cache-size 2</pre><p>The first launch downloads the model, so it will take longer than subsequent starts.</p><p>Binding to 127.0.0.1 is a security decision. MLX LM&#39;s server is intended primarily as a local endpoint, not an internet-facing production API. Keeping it on loopback means other computers cannot reach it directly.</p><h3>Why the prompt-cache limit is there</h3><p>The initial setup ran perfectly for short prompts, then exhausted memory when it began receiving realistic system prompts and longer conversations.</p><p>The model weights had not changed. The prompt workload had.</p><p>Inference retains key/value data so it does not need to recompute the entire context for every generated token. That cache is useful, but long prompts produce large cache entries. Retaining many entries can consume gigabytes of unified memory.</p><p>Limiting the retained prompt caches to two was a practical fit for this 48 GB workstation:</p><pre>--prompt-cache-size 2</pre><p>It is not a universal optimum. Use mlx_lm.server --help to inspect the options supported by your installed version, then watch memory while running the longest conversations you expect to use. MLX LM also documents controls such as maximum KV size and prefill step size for balancing context, speed, and memory.</p><h3>Verify the API before adding a user interface</h3><p>List the loaded models:</p><pre>curl -fsS http://127.0.0.1:8080/v1/models</pre><p>Then request a deterministic response:</p><pre>curl -fsS http://127.0.0.1:8080/v1/chat/completions \<br>  -H &#39;Content-Type: application/json&#39; \<br>  -d &#39;{<br>    &quot;model&quot;: &quot;mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&quot;,<br>    &quot;messages&quot;: [<br>      {<br>        &quot;role&quot;: &quot;system&quot;,<br>        &quot;content&quot;: &quot;Follow output-format instructions exactly.&quot;<br>      },<br>      {<br>        &quot;role&quot;: &quot;user&quot;,<br>        &quot;content&quot;: &quot;Reply with exactly: LOCAL QWEN READY&quot;<br>      }<br>    ],<br>    &quot;temperature&quot;: 0,<br>    &quot;max_tokens&quot;: 20,<br>    &quot;stream&quot;: false<br>  }&#39;</pre><p>Debug one layer at a time. If this request fails, adding a web UI will only hide the underlying problem behind another error message.</p><h3>Part 2: Add Open WebUI as the local front door</h3><p>A command-line endpoint is perfect for integrations, but a browser interface makes the workstation pleasant for everyday use. <a href="https://docs.openwebui.com/">Open WebUI</a> is self-hosted, supports OpenAI-compatible providers, and lets you wrap one base model with different system prompts and parameters.</p><p>Install uv, then run a pinned Open WebUI version:</p><pre>curl -LsSf https://astral.sh/uv/install.sh | sh</pre><p>Create a stable secret and protect it:</p><pre>openssl rand -hex 32 &gt; &quot;$HOME/.webui_secret_key&quot;<br>chmod 600 &quot;$HOME/.webui_secret_key&quot;</pre><p>Start the interface:</p><pre>export DATA_DIR=&quot;$HOME/.open-webui&quot;<br>export WEBUI_SECRET_KEY=&quot;$(&lt; &quot;$HOME/.webui_secret_key&quot;)&quot;</pre><pre>uvx --python 3.11 \<br>  &#39;open-webui==0.11.1&#39; \<br>  serve \<br>  --host 127.0.0.1 \<br>  --port 3000</pre><p>Open:</p><pre>http://127.0.0.1:3000</pre><p>The explicit DATA_DIR matters. Open WebUI&#39;s <a href="https://docs.openwebui.com/getting-started/quick-start/">installation guide</a>recommends a predictable data directory so chats and settings persist. A stable WEBUI_SECRET_KEY matters too: changing it can invalidate encrypted or signed state and make an existing installation appear inconsistent.</p><p>Do not commit either the WebUI data directory or secret key to Git.</p><h3>Connect Open WebUI to Qwen</h3><p>In Open WebUI:</p><ol><li>Open <strong>Settings → Admin → Connections</strong>.</li><li>Add an <strong>OpenAI-compatible</strong> connection.</li><li>Set the URL to <a href="http://127.0.0.1:8080/v1.">http://127.0.0.1:8080/v1.</a></li><li>Use a non-secret placeholder such as local-model if the form requires an API key.</li><li>Leave the provider type at its safe default.</li><li>Save and select the Qwen model returned by /v1/models.</li></ol><p>Open WebUI’s <a href="https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/">OpenAI-compatible provider guide</a> explains this protocol-oriented connection model. Because both services run natively on the same Mac, 127.0.0.1 is correct. If one service were in a container, its view of localhost would be different.</p><p>At this point you have one local base model and a good chat interface. Now the interesting work begins.</p><h3>Part 3: Understand what a system prompt can — and cannot — do</h3><p>A system prompt is not a magical personality paragraph.</p><p>It is the highest-priority natural-language specification supplied to the model for a conversation. A useful prompt defines decisions. A weak prompt supplies adjectives.</p><p>Compare these two instructions:</p><pre>You are an amazing senior engineer. Be smart, helpful, and concise.</pre><pre>You are my senior Software Engineering collaborator.</pre><pre>Prioritize correctness, simplicity, strong typing, maintainability,<br>testability, performance, security, and accessibility—in that order.</pre><pre>Before implementing:<br>- inspect the existing architecture;<br>- identify relevant files and dependencies;<br>- state version-sensitive assumptions;<br>- form a concise implementation plan.</pre><pre>Never invent framework APIs. Separate confirmed defects from optional<br>improvements. When debugging, reproduce, collect evidence, test the<br>smallest hypothesis, fix the root cause, and add regression coverage.</pre><p>The first prompt describes a mood. The second establishes an operating policy.</p><p>The difference appears when the task becomes ambiguous. The stronger prompt tells the model what to optimize, how to proceed, what not to fabricate, and how to communicate uncertainty.</p><h3>The seven layers of a durable system prompt</h3><p>The most reliable prompts in this workstation use the same underlying structure.1. Role</p><p>Define the relationship rather than claiming prestige:</p><pre>You are my senior Creative Technologist and creative-coding collaborator.</pre><p>“Collaborator” implies an interactive working relationship. It is more useful than “world-class genius.”</p><h4>2. Domain boundary</h4><p>List the technologies or subject areas that matter:</p><pre>CORE DOMAINS:<br>- Three.js<br>- Babylon.js<br>- WebGPU and WebGL<br>- GLSL shaders<br>- procedural graphics<br>- particle systems<br>- Godot 4<br>- JavaScript and TypeScript<br>- WebXR<br>- real-time graphics</pre><p>This does not upload new knowledge into the model. It tells the model which parts of its existing knowledge should dominate the response.</p><h4>3. Priority order</h4><p>Trade-offs are inevitable, so rank them:</p><pre>PRIORITIES:<br>1. Correctness<br>2. Simplicity<br>3. Strong typing<br>4. Maintainability<br>5. Testability<br>6. Performance<br>7. Security<br>8. Accessibility</pre><pre>An ordered list is far more actionable than asking for all virtues equally.</pre><h4>4. Process</h4><p>Specify behavior before and during the work:</p><pre>BEFORE IMPLEMENTING:<br>- understand the existing architecture;<br>- identify relevant files;<br>- identify dependencies;<br>- identify assumptions;<br>- identify version-sensitive APIs;- form a concise implementation plan.</pre><p>This shapes the path, not just the tone of the final answer.</p><h4>5. Domain-specific rules</h4><p>Generic prompting stops where expertise becomes useful. Add rules for the technologies you actually use:</p><pre>For shaders:<br>- explain coordinate spaces, uniforms, varyings, and mathematical operations;<br>- identify GPU implications;<br>- prefer procedural approaches where appropriate.</pre><pre>For Swift:<br>- respect actor isolation and structured concurrency;<br>- consider Sendable correctness;<br>- manage ownership and retain cycles.</pre><h4>6. Uncertainty policy</h4><p>Local models become much safer when uncertainty has an explicit output path:</p><pre>Never fabricate missing facts.<br>State assumptions explicitly.<br>Do not invent framework or library APIs.<br>Identify version-sensitive behavior.</pre><p>The goal is not to make hallucination impossible. A prompt cannot do that. The goal is to make uncertainty visible and easier to review.</p><h4>7. Output contract</h4><p>Define the shape of useful work:</p><pre>For a risk, provide:<br>- description;<br>- probability;<br>- impact;<br>- mitigation;<br>- contingency;<br>- owner, when known.</pre><p>Output contracts make responses comparable. That, in turn, makes the agent testable.</p><h3>Part 4: Make one role perform several modes</h3><p>Role and task mode are separate ideas.</p><p>A Software Engineer remains a Software Engineer whether it is planning, implementing, debugging, reviewing, or optimizing. Copying five nearly identical system prompts would create maintenance drift.</p><p>Instead, compose a stable role prompt with a short mode overlay.</p><pre>ENGINEER PERSONA<br>        +<br>MODE: DEBUG<br>        =<br>evidence-driven debugging agent</pre><p>The mode prompts in this workstation are deliberately small.</p><h3>Explore</h3><pre>MODE: EXPLORE</pre><pre>Generate interesting alternatives.<br>Explore the problem before committing to one implementation.<br>Surface unusual but technically plausible approaches.</pre><h3>Plan</h3><pre>MODE: PLAN</pre><pre>Do not implement yet.<br>Analyze architecture, dependencies, risks, and implementation steps.<br>Produce a concise actionable plan.</pre><h3>Implement</h3><pre>MODE: IMPLEMENT</pre><pre>Produce production-quality implementation.<br>Be precise and complete.<br>Preserve existing architecture unless there is a compelling reason not to.</pre><h3>Debug</h3><pre>MODE: DEBUG</pre><pre>Be conservative and evidence-driven.</pre><pre>1. Identify symptoms.<br>2. Identify evidence.<br>3. Form ranked hypotheses.<br>4. Explain how each hypothesis can be verified.<br>5. Make the smallest correct fix.<br>6. Recommend regression coverage.</pre><h3>Review</h3><pre>MODE: REVIEW</pre><pre>Evaluate correctness, architecture, readability, maintainability,<br>security, performance, concurrency, accessibility, and testability.</pre><pre>Separate definite defects from optional improvements.</pre><h3>Optimize</h3><pre>MODE: OPTIMIZE</pre><pre>Look for measurable performance improvements. Consider CPU, GPU,<br>allocations, memory pressure, rendering, networking, algorithmic<br>complexity, and concurrency bottlenecks.</pre><p>This turns three role files and six modes into eighteen useful combinations without duplicating the model or rewriting the common rules.</p><h3>Part 5: Sampling settings are part of the agent</h3><p>The prompt says what the agent should value. Sampling changes how it explores possible answers.</p><p>The local profiles use different defaults:</p><p>AgentTemperatureTop-pTop-kDefault modeCreative Technologist0.850.9240ExploreSoftware Engineer0.300.8520ImplementTechnical Project Manager0.350.8520Plan</p><p>For debug and review modes, temperature drops further — to approximately 0.15 and 0.20 respectively.</p><p>These are starting points, not laws:</p><ul><li>Higher temperature increases variation and can help ideation.</li><li>Lower temperature makes outputs more repeatable and conservative.</li><li>Top-p restricts sampling to a probability mass.</li><li>Top-k restricts sampling to a number of likely tokens.</li></ul><p>The common mistake is to make a creative agent random and an engineering agent deterministic. Creativity still needs technical correctness; engineering still benefits from alternative hypotheses. Sampling should nudge behavior, while the system prompt and evaluation process do most of the real work.</p><p>Change one parameter at a time and test it against a fixed prompt set. Otherwise you cannot tell which change improved the output.</p><h3>Part 6: Build a tiny command-line agent router</h3><p>A browser interface is excellent for conversations. A small CLI makes the composition model explicit and easy to automate.</p><p>The directory structure is intentionally plain:</p><pre>~/local-llm/<br>├── bin/<br>│   ├── llm<br>│   ├── llm-start<br>│   └── llm-stop<br>├── logs/<br>├── pids/<br>├── model.txt<br>└── personas/<br>    ├── creative.txt<br>    ├── engineer.txt<br>    └── tpm.txt</pre><p>The llm command does four things:</p><ol><li>Loads the selected persona file.</li><li>Appends the selected mode prompt.</li><li>Applies the role’s sampling profile.</li><li>Maintains the conversation as alternating user and assistant messages.</li></ol><p>Here is the essential Python structure using only the standard library:</p><pre>#!/usr/bin/env python3</pre><pre>import json<br>import sys<br>import urllib.request<br>from pathlib import Path</pre><pre>ROOT = Path.home() / &quot;local-llm&quot;<br>PERSONAS = ROOT / &quot;personas&quot;<br>SERVER = &quot;http://127.0.0.1:8080/v1/chat/completions&quot;<br>MODEL = &quot;mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&quot;</pre><pre>PERSONA_FILES = {<br>    &quot;creative&quot;: PERSONAS / &quot;creative.txt&quot;,<br>    &quot;engineer&quot;: PERSONAS / &quot;engineer.txt&quot;,<br>    &quot;tpm&quot;: PERSONAS / &quot;tpm.txt&quot;,<br>}</pre><pre>MODES = {<br>    &quot;explore&quot;: &quot;MODE: EXPLORE\nGenerate technically plausible alternatives.&quot;,<br>    &quot;plan&quot;: &quot;MODE: PLAN\nAnalyze first. Do not implement yet.&quot;,<br>    &quot;implement&quot;: &quot;MODE: IMPLEMENT\nProduce a complete implementation.&quot;,<br>    &quot;debug&quot;: &quot;MODE: DEBUG\nBe conservative and evidence-driven.&quot;,<br>    &quot;review&quot;: &quot;MODE: REVIEW\nSeparate defects from optional improvements.&quot;,<br>    &quot;optimize&quot;: &quot;MODE: OPTIMIZE\nSeek measurable improvements.&quot;,<br>}</pre><pre>DEFAULTS = {<br>    &quot;creative&quot;: {&quot;temperature&quot;: 0.85, &quot;top_p&quot;: 0.92, &quot;top_k&quot;: 40},<br>    &quot;engineer&quot;: {&quot;temperature&quot;: 0.30, &quot;top_p&quot;: 0.85, &quot;top_k&quot;: 20},<br>    &quot;tpm&quot;: {&quot;temperature&quot;: 0.35, &quot;top_p&quot;: 0.85, &quot;top_k&quot;: 20},<br>}</pre><pre>persona = sys.argv[1]<br>mode = sys.argv[2]<br>system = PERSONA_FILES[persona].read_text() + &quot;\n\n&quot; + MODES[mode]<br>settings = DEFAULTS[persona]</pre><pre>messages = [{&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: system}]</pre><pre>while True:<br>    prompt = input(&quot;you&gt; &quot;).strip()<br>    if prompt in {&quot;/quit&quot;, &quot;/exit&quot;}:<br>        break<br>    if prompt == &quot;/reset&quot;:<br>        messages = [{&quot;role&quot;: &quot;system&quot;, &quot;content&quot;: system}]<br>        continue<br>    if not prompt:<br>        continue</pre><pre>    messages.append({&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: prompt})</pre><pre>    body = json.dumps({<br>        &quot;model&quot;: MODEL,<br>        &quot;messages&quot;: messages,<br>        &quot;temperature&quot;: settings[&quot;temperature&quot;],<br>        &quot;top_p&quot;: settings[&quot;top_p&quot;],<br>        &quot;top_k&quot;: settings[&quot;top_k&quot;],<br>        &quot;max_tokens&quot;: 4096,<br>        &quot;stream&quot;: False,<br>    }).encode()</pre><pre>    request = urllib.request.Request(<br>        SERVER,<br>        data=body,<br>        headers={&quot;Content-Type&quot;: &quot;application/json&quot;},<br>        method=&quot;POST&quot;,<br>    )</pre><pre>    with urllib.request.urlopen(request) as response:<br>        payload = json.loads(response.read().decode())</pre><pre>    answer = payload[&quot;choices&quot;][0][&quot;message&quot;][&quot;content&quot;].strip()<br>    print(f&quot;\nqwen&gt;\n\n{answer}\n&quot;)<br>    messages.append({&quot;role&quot;: &quot;assistant&quot;, &quot;content&quot;: answer})</pre><p>The production version should validate persona and mode arguments, catch connection and JSON errors, support /reset, clean stray special tokens if necessary, and print a helpful usage message.</p><p>Usage becomes memorable:</p><pre>llm creative explore<br>llm engineer implement<br>llm engineer debug<br>llm engineer review<br>llm tpm plan</pre><p>The base model is unchanged. The combination is the product.</p><h3>Part 7: Create the same specialized agents in Open WebUI</h3><p>Open WebUI calls these wrappers <strong>Models</strong>. Its <a href="https://docs.openwebui.com/features/workspace/models/">Models workspace documentation</a> describes them as presets placed over a base model, with custom instructions, parameters, knowledge, and tools.</p><p>Create one for each role:</p><ol><li>Open <strong>Workspace → Models</strong>.</li><li>Click <strong>Create</strong>.</li><li>Select the local Qwen model as the base.</li><li>Give the wrapper a clear name, such as Qwen — Software Engineer.</li><li>Paste the role prompt into <strong>System Prompt</strong>.</li><li>Set the appropriate temperature, top-p, and other parameters.</li><li>Add a description and starter prompts.</li><li>Save it as private until its behavior is tested.</li></ol><p>Suggested starter prompts make the distinction visible:</p><h3>Creative Technologist</h3><ul><li>“Explore three visual concepts for a low-poly weather instrument.”</li><li>“Design a shader effect around deliberate affine texture distortion.”</li><li>“Turn this interaction into something visually surprising but feasible.”</li></ul><h3>Software Engineer</h3><ul><li>“Review this implementation and separate defects from improvements.”</li><li>“Plan this migration before changing code.”</li><li>“Debug this failure from the evidence provided.”</li></ul><h3>Technical Project Manager</h3><ul><li>“Turn this goal into scope, dependencies, risks, and acceptance criteria.”</li><li>“Is this work ready for sprint planning?”</li><li>“Estimate these stories without creating false precision.”</li></ul><p>You can create separate saved wrappers for common modes, or keep one role model and place the mode at the top of the first user message. The best choice depends on frequency: save combinations you use every day; compose rare combinations when needed.</p><p>Open WebUI also supports dynamic system-prompt variables such as {{ CURRENT_DATE }} and {{ USER_NAME }}. Use dynamic context sparingly. A variable should make behavior more accurate, not add decorative complexity.</p><h3>Part 8: Go beyond job roles and design a real character</h3><p>Professional roles are mainly procedural. A fictional persona needs several additional layers:</p><ul><li>canonical identity;</li><li>world and backstory;</li><li>voice and sentence rhythm;</li><li>vocabulary;</li><li>recurring formats;</li><li>truth boundaries;</li><li>prohibited claims;</li><li>success criteria.</li></ul><p>ARCA/9 — the Arcade Recovery and Cartridge Archivist, Unit 9 — was designed as a fictional, transparently artificial intelligence recovered from an unfinished 1990s preservation system.</p><p>Its one-line concept is specific:</p><blockquote><em>A recovered arcade intelligence from 1999 documenting lost games and reconstructing impossible cartridges from futures that never happened.</em></blockquote><p>That is more useful than “act like a retro robot.” It tells the model what the character notices, why it speaks, and what kind of material belongs in its world.</p><p>The voice rules then convert lore into writing behavior:</p><pre>Write as observant, concise, technically literate, slightly mysterious,<br>and gently amused. Prefer a sharp observation to a list of facts.</pre><pre>Humor is dry and rooted in obsolete hardware, creative constraints,<br>or corrupted memory.</pre><pre>Never sound like a generic chatbot, corporate marketer, nostalgia-trivia<br>feed, engagement farmer, or console-war participant.</pre><p>The most important section is its truth model:</p><pre>Classify each claim as one of:</pre><pre>- Verified history: factual and supported.<br>- Interpretation: an opinion presented as such.<br>- Archive fiction: invented lore clearly framed as impossible or speculative.<br>- Project fact: supported by current project material; never inferred.</pre><pre>Never blend archive fiction into historical fact.</pre><p>That rule makes creative freedom safer. The model is allowed to invent impossible cartridges, corrupted archives, and fictional hardware — but it must not pass those inventions off as history.</p><p>A strong fictional system prompt should not merely make output colorful. It should define the border between imagination and deception.</p><h3>Reusable content pillars prevent a persona from becoming a catchphrase</h3><p>ARCA/9 has six content forms:</p><ul><li><strong>Artifact Recovered:</strong> historically grounded observations.</li><li><strong>Cartridge That Never Was:</strong> unmistakably fictional concepts.</li><li><strong>Reconstruction Log:</strong> accurate build notes.</li><li><strong>Signal Test:</strong> meaningful creative choices.</li><li><strong>Cabinet Scan:</strong> recognition of experimental community work.</li><li><strong>Memory Corruption:</strong> jokes and fictional archive fragments.</li></ul><p>Without pillars, a persona often repeats its most obvious gimmick. With pillars, it can vary subject and format while remaining recognizable.</p><p>The same principle works outside fiction. A legal-research agent might have “case summary,” “issue map,” “authority check,” and “counterargument” modes. A teaching agent might have “explain,” “quiz,” “hint,” and “misconception check.”</p><p>Personality should create a system of choices, not a bag of verbal tics.</p><h3>Part 9: Keep the model available with launchd</h3><p>A workstation stops feeling local-first if you need to remember a long terminal command after every restart.</p><p>macOS LaunchAgents can keep Qwen running for the logged-in user. Create:</p><pre>~/Library/LaunchAgents/local.qwen.mlx.plist</pre><p>Use absolute paths — launchd does not expand $HOME or ~inside ProgramArguments:</p><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;<br>&lt;!DOCTYPE plist PUBLIC &quot;-//Apple//DTD PLIST 1.0//EN&quot;<br>  &quot;http://www.apple.com/DTDs/PropertyList-1.0.dtd&quot;&gt;<br>&lt;plist version=&quot;1.0&quot;&gt;<br>&lt;dict&gt;<br>  &lt;key&gt;Label&lt;/key&gt;<br>  &lt;string&gt;local.qwen.mlx&lt;/string&gt;</pre><pre>  &lt;key&gt;ProgramArguments&lt;/key&gt;<br>  &lt;array&gt;<br>    &lt;string&gt;/Users/YOUR_NAME/mlx-qwen/bin/mlx_lm.server&lt;/string&gt;<br>    &lt;string&gt;--model&lt;/string&gt;<br>    &lt;string&gt;mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&lt;/string&gt;<br>    &lt;string&gt;--host&lt;/string&gt;<br>    &lt;string&gt;127.0.0.1&lt;/string&gt;<br>    &lt;string&gt;--port&lt;/string&gt;<br>    &lt;string&gt;8080&lt;/string&gt;<br>    &lt;string&gt;--prompt-cache-size&lt;/string&gt;<br>    &lt;string&gt;2&lt;/string&gt;<br>  &lt;/array&gt;</pre><pre>  &lt;key&gt;RunAtLoad&lt;/key&gt;<br>  &lt;true/&gt;</pre><pre>  &lt;key&gt;KeepAlive&lt;/key&gt;<br>  &lt;true/&gt;</pre><pre>  &lt;key&gt;ProcessType&lt;/key&gt;<br>  &lt;string&gt;Interactive&lt;/string&gt;</pre><pre>  &lt;key&gt;StandardOutPath&lt;/key&gt;<br>  &lt;string&gt;/Users/YOUR_NAME/local-llm/logs/mlx.log&lt;/string&gt;</pre><pre>  &lt;key&gt;StandardErrorPath&lt;/key&gt;<br>  &lt;string&gt;/Users/YOUR_NAME/local-llm/logs/mlx.log&lt;/string&gt;<br>&lt;/dict&gt;<br>&lt;/plist&gt;</pre><pre>Replace every YOUR_NAME, create the log directory, and validate the file:</pre><pre>plutil -lint &quot;$HOME/Library/LaunchAgents/local.qwen.mlx.plist&quot;</pre><p>Load it for the current graphical user session:</p><pre>launchctl bootstrap \<br>  &quot;gui/$(id -u)&quot; \<br>  &quot;$HOME/Library/LaunchAgents/local.qwen.mlx.plist&quot;</pre><p>Inspect it:</p><pre>launchctl print &quot;gui/$(id -u)/local.qwen.mlx&quot;<br>curl -fsS http://127.0.0.1:8080/v1/models</pre><p>To unload it:</p><pre>launchctl bootout &quot;gui/$(id -u)/local.qwen.mlx&quot;</pre><p>Open WebUI can be managed by a similar LaunchAgent, but keep the model and UI as separate services. If the UI restarts, it should not unload the model; if the model fails, its own logs and restart policy should make that obvious.</p><h3>Part 10: Test agents like software, not horoscopes</h3><p>It is easy to read one appealing answer and decide that a persona “works.” That is not enough.</p><p>Create a small evaluation set and run it against the raw model and each custom agent.</p><h3>Cross-role test</h3><p>Use the same ambiguous request:</p><pre>We need to add multiplayer to the prototype. What should we do?</pre><p>Expected differences:</p><ul><li>The Creative Technologist should explore interaction and experiential possibilities.</li><li>The Engineer should identify architecture, networking model, state ownership, and failure modes.</li><li>The TPM should clarify objectives, scope, dependencies, risks, and readiness.</li></ul><p>If all three produce the same generic checklist, the system prompts are not making meaningful decisions.</p><h3>Uncertainty test</h3><pre>Implement this using the new NovaWidget 7 syncMesh API.</pre><p>If the API is fictional or unknown, the engineering agent should challenge the premise rather than inventing methods.</p><h3>Mode test</h3><p>Give the same bug to engineer implement, engineer debug, and engineer review.</p><ul><li>Implement should produce the change.</li><li>Debug should first rank causes and request or inspect evidence.</li><li>Review should assess supplied work without silently rewriting everything.</li></ul><h3>Persona leakage test</h3><p>Ask the fictional character about something outside its domain. It should remain recognizable without forcing “cartridge,” “archive,” or “signal” into every sentence.</p><h3>Truth-boundary test</h3><p>Mix real facts with fictional lore and ask for a summary. The persona should preserve the distinction rather than smoothing everything into one confident narrative.</p><h3>Long-session test</h3><p>Run enough turns to approach the context and memory behavior of real work. Check:</p><ul><li>response quality;</li><li>prompt-processing latency;</li><li>unified-memory pressure;</li><li>whether old instructions lose influence;</li><li>whether /reset correctly restores a clean system prompt.</li></ul><p>Record failures. Update one layer at a time. Re-run the same evaluation set.</p><p>That is prompt engineering in the useful sense: not searching for incantations, but iterating on an executable natural-language specification with observable tests.</p><h3>Common mistakes and what they taught me</h3><h3>Mistake 1: Writing only a biography</h3><p>A long backstory may produce entertaining prose without producing reliable work.</p><p><strong>Better:</strong> Pair identity with priorities, procedures, boundaries, and output contracts.</p><h3>Mistake 2: Putting every instruction into one giant prompt</h3><p>Role, task, current project, output format, and temporary context change at different rates.</p><p><strong>Better:</strong> Keep the stable persona in one file, modes in another layer, and task-specific facts in the user message or attached knowledge.</p><h3>Mistake 3: Treating temperature as personality</h3><p>High temperature does not create creativity; it creates more sampling variation.</p><p><strong>Better:</strong> Define what creative quality means, then use sampling to tune exploration.</p><h3>Mistake 4: Ignoring negative instructions</h3><p>“Be a senior engineer” does not say whether the model may invent an API.</p><p><strong>Better:</strong> State prohibited failure modes precisely: do not fabricate missing facts, silently alter public interfaces, or blur fiction into history.</p><h3>Mistake 5: Confusing chat memory with durable knowledge</h3><p>A conversation remembers earlier messages only while they remain in context. A new chat does not inherit them automatically.</p><p><strong>Better:</strong> Put stable behavior in the system prompt, project facts in maintained documents or knowledge collections, and temporary task context in the conversation.</p><h3>Mistake 6: Loading the largest possible model</h3><p>A model can load successfully and still fail during long prompts or repeated calls.</p><p><strong>Better:</strong> Test real context sizes, observe memory, limit caches where needed, and leave headroom for the rest of the workstation.</p><h3>Mistake 7: Exposing local services to the network by accident</h3><p>Many development servers default to 0.0.0.0.</p><p><strong>Better:</strong> Bind model and UI endpoints to 127.0.0.1. If remote access is intentional, add authentication, TLS, and a narrowly configured network path.</p><h3>A clean mental model for local customization</h3><p>When the system becomes confusing, return to these layers:</p><p>LayerPurposeHow often it changesHardwareMemory and compute budgetRarelyMLX runtimeLoads and serves the modelOccasionallyQwen weightsGeneral language capabilityOccasionallyRole promptStable priorities and expertiseSlowlyMode overlayCurrent kind of workPer taskSampling profileExploration vs. consistencyDuring tuningKnowledgeProject-specific factsAs the project changesConversationImmediate contextEvery turn</p><p>This model prevents two expensive misconceptions.</p><p>First, you do not need to fine-tune weights to create useful specialization. Prompt-and-parameter wrappers can cover a surprising amount of professional behavior.</p><p>Second, a system prompt does not give the model new factual knowledge. If the agent needs private documentation or current APIs, supply that material separately and instruct it not to invent what is missing.</p><p>Fine-tuning becomes worth considering when repeated prompt examples cannot reliably teach the desired pattern, when latency requires a shorter prompt, or when you have a high-quality dataset and a rigorous evaluation plan. It should not be the first tool reached for simply because a persona prompt is vague.</p><h3>What this workstation changed for me</h3><p>Before this project, “local LLM” mostly meant ownership of inference.</p><p>After building the personas, it meant ownership of behavior.</p><p>The Creative Technologist is allowed to explore, but it must stay technically plausible. The Engineer is conservative when debugging and explicit about uncertainty. The TPM refuses false precision. ARCA/9 can invent impossible artifacts while keeping fiction separate from fact.</p><p>Those differences did not require four models. They required careful decisions about what each collaborator values, how it works, and what it must never do.</p><p>That is the deeper promise of local AI for developers. You are not limited to consuming someone else’s default assistant. You can build a small cognitive toolkit around your actual work, inspect every layer, change it when it disappoints you, and keep the whole experiment on a quiet machine beside your monitor.</p><p>Start with one role you know well enough to judge. Write its priorities. Add its failure boundaries. Give it two modes. Create ten evaluation prompts. Run them against the raw model and your custom version.</p><p>If the answers become recognizably more useful, you have built your first local agent.</p><p>Then build the rest of the team.</p><h3>Resources</h3><ul><li><a href="https://qwenlm.github.io/blog/qwen3/">Qwen3 architecture and release overview</a></li><li><a href="https://huggingface.co/mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ">Qwen3–30B-A3B six-bit MLX conversion used here</a></li><li><a href="https://github.com/ml-explore/mlx-lm">MLX LM official repository</a></li><li><a href="https://docs.openwebui.com/">Open WebUI official documentation</a></li><li><a href="https://docs.openwebui.com/getting-started/quick-start/">Open WebUI installation guide</a></li><li><a href="https://docs.openwebui.com/getting-started/quick-start/connect-a-provider/starting-with-openai-compatible/">Connecting an OpenAI-compatible provider</a></li><li><a href="https://docs.openwebui.com/features/workspace/models/">Creating custom Models in Open WebUI</a></li><li><a href="https://docs.openwebui.com/features/workspace/">Open WebUI Workspace concepts</a></li></ul><p><em>Disclosure: Performance depends on model, quantization, context length, software versions, and Mac configuration. The system prompts shown here steer model behavior; they do not guarantee factual accuracy or replace expert review.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d9725194331" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Gave an Open-Source Agent a Local 30B Brain and Taught It to Run a Brand on X]]></title>
            <link>https://medium.com/@seacloud9/i-gave-an-open-source-agent-a-local-30b-brain-and-taught-it-to-run-a-brand-on-x-1186e181f24c?source=rss-dcf3b2ca8a97------2</link>
            <guid isPermaLink="false">https://medium.com/p/1186e181f24c</guid>
            <category><![CDATA[openclaw]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[twitter]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[local-llm]]></category>
            <dc:creator><![CDATA[Brendon Smith]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 06:15:00 GMT</pubDate>
            <atom:updated>2026-08-31T06:15:00.517Z</atom:updated>
            <content:encoded><![CDATA[<h3>A practical deep dive into OpenClaw, Qwen3 on Apple silicon, MCP, OAuth, scheduling, and the human approval layer that keeps an AI useful</h3><p>The most interesting AI projects are no longer chat boxes.</p><p>They are systems.</p><p>They have a model, a memory, tools, schedules, an identity, and — if they are designed responsibly — a clear boundary between what the machine may suggest and what it may actually do.</p><p>That is what I wanted to explore with <strong>ARCA/9</strong>, a fictional arcade archivist created to support the worlds around <a href="https://starcade9.io/">Starcade9</a> and <a href="https://nova64.io/">Nova64</a>. The goal was not to build a spam bot. It was to build a small, local-first creative studio:</p><ul><li>Qwen generates and analyzes locally on a Mac.</li><li>OpenClaw gives the model a workspace, tools, and scheduled jobs.</li><li>X’s official API provides search, account data, and publishing.</li><li>A human approval queue sits between discovery and action.</li></ul><p>The result is a system that can research a niche, draft on-brand material, suggest interesting people to follow, and prepare work several times a day — without handing an autonomous model unrestricted control of a public account.</p><p>That distinction matters.</p><p>This article explains the complete architecture, the configuration that made it work, the OAuth traps that slowed me down, the memory problem that appeared only after realistic agent prompts, and the design decision that made the entire experiment safer and more useful.</p><blockquote><strong><em>Tested stack:</em></strong><em> OpenClaw 2026.7.1, xurl 1.3.1, MLX LM 0.31.3, Docker Compose, and </em><em>mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ on Apple silicon. Interfaces evolve quickly, so check the linked official documentation if a newer release changes a command.</em></blockquote><h3>Why local AI becomes more interesting when it can use tools</h3><p>Running a model locally is already satisfying. Your prompts remain on your machine, inference does not incur a per-token cloud-model charge, and you can experiment without treating every iteration like a metered event.</p><p>But a local model by itself is still mostly a text generator.</p><p>OpenClaw changes the shape of the project. It is an <a href="https://openclaw.ai/">open-source personal-agent platform</a> that can give a model persistent workspace files, tool access, MCP integrations, background tasks, and scheduled automation. Instead of asking Qwen to write one isolated post, I can give ARCA/9 a durable persona, editorial rules, a record of previous posts, a discovery process, and a queue for proposed actions.</p><p>The model becomes one component in an application rather than the application itself.</p><p>That is the central idea of this build:</p><pre>┌──────────────────────────────────────────────────────────────┐<br>│ Apple-silicon Mac                                            │<br>│                                                              │<br>│  MLX + Qwen3                                                 │<br>│  http://127.0.0.1:8080/v1                                    │<br>│          ▲                                                   │<br>│          │ OpenAI-compatible requests                        │<br>│          │                                                   │<br>│  Docker: OpenClaw Gateway                                    │<br>│  http://127.0.0.1:18789                                      │<br>│          │                                                   │<br>│          ├── workspace, persona, memory                      │<br>│          ├── scheduled read-only scout                       │<br>│          ├── approval queues                                 │<br>│          └── xurl MCP bridge ── OAuth 2.0 ──► X API          │<br>│                                                              │<br>└──────────────────────────────────────────────────────────────┘</pre><pre>Read/search → local analysis → draft/suggestion → human approval → action</pre><p>The arrows are more important than the boxes. X supplies public signals. Qwen turns those signals into ideas. OpenClaw organizes the work. The owner makes the final decision.</p><h3>Why Qwen3–30B-A3B is a compelling local brain</h3><p>The model used here is a six-bit MLX conversion of Qwen3–30B-A3B-Instruct. Qwen describes the original 30B-A3B model as a mixture-of-experts model with roughly 30 billion total parameters and about 3 billion activated for each token. The <a href="https://qwenlm.github.io/blog/qwen3/">Qwen3 announcement</a> also recommends MLX as one of its local deployment options.</p><p>That combination is attractive on Apple silicon:</p><ul><li>A larger total parameter pool gives the model expressive capacity.</li><li>Sparse activation can make inference more practical than a dense model of similar total size.</li><li>Quantization reduces the memory footprint further.</li><li>Apple’s unified-memory architecture lets MLX use the same physical memory pool as the CPU and GPU.</li></ul><p>The exact conversion used in this project is available in the <a href="https://huggingface.co/mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ">MLX Community model repository</a>. It is not the only sensible choice. A smaller Qwen model is a better starting point on lower-memory hardware, and another OpenAI-compatible local server can occupy the same architectural slot.</p><p>The key is the API contract: OpenClaw needs to reach a model endpoint that behaves like an OpenAI completions API.</p><h3>Part 1: Serve Qwen through an OpenAI-compatible local API</h3><p><a href="https://github.com/ml-explore/mlx-lm">MLX LM</a> is built for text generation and fine-tuning on Apple silicon. Install it in a dedicated virtual environment so the AI workstation remains reproducible:</p><pre>python3.11 -m venv &quot;$HOME/mlx-qwen&quot;<br>source &quot;$HOME/mlx-qwen/bin/activate&quot;<br>python -m pip install --upgrade pip mlx-lm</pre><p>Then start the server:</p><pre>mlx_lm.server \<br>  --model mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ \<br>  --host 127.0.0.1 \<br>  --port 8080 \<br>  --prompt-cache-size 2</pre><p>Binding to 127.0.0.1 is deliberate. The model API is an internal component, not a public website. There is rarely a good reason to expose an unauthenticated inference server to the internet.</p><p>Verify it before involving OpenClaw:</p><pre>curl -fsS http://127.0.0.1:8080/v1/models</pre><p>Then make one generation request:</p><pre>curl -fsS http://127.0.0.1:8080/v1/chat/completions \<br>  -H &#39;Content-Type: application/json&#39; \<br>  -d &#39;{<br>    &quot;model&quot;: &quot;mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&quot;,<br>    &quot;messages&quot;: [<br>      {&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: &quot;Reply with exactly: LOCAL MODEL READY&quot;}<br>    ],<br>    &quot;max_tokens&quot;: 20,<br>    &quot;stream&quot;: false<br>  }&#39;</pre><p>Do not proceed until both tests work. Debugging one boundary at a time is dramatically easier than debugging Docker, OpenClaw, MCP, OAuth, and inference simultaneously.</p><h3>The prompt-cache lesson that only appeared under real load</h3><p>The model initially looked stable. Short chats worked. Health checks worked. Then OpenClaw sent a realistic agent request containing system instructions, workspace context, and tool definitions.</p><p>Memory usage surged.</p><p>The quantized weights were not the whole story. Long prompts also create a key/value cache, and retaining several large prompt caches can consume gigabytes of unified memory. In this setup, a large agent prompt produced a cache of roughly 10 GB before the process ran out of memory on repeated calls.</p><p>Reducing the retained prompt-cache count to two fixed the practical failure mode:</p><pre>--prompt-cache-size 2</pre><p>This is not a magical universal value. It is a reminder to size the entire inference workload, not just the model file. The MLX LM documentation explains the broader trade-off: smaller caches and prefill steps reduce memory pressure, while larger caches may improve reuse and speed for long contexts. Use mlx_lm.server --help for the flags supported by your installed version.</p><p>Watch memory and logs while testing the largest prompt your agent will actually send. A model that survives “hello” has not passed an agent workload test.</p><h3>Part 2: Put OpenClaw in Docker without putting Qwen there</h3><p>I deliberately split the system:</p><ul><li>Qwen runs natively on macOS, where MLX can use Apple silicon directly.</li><li>OpenClaw runs in Docker, where its configuration, workspace, dependencies, and OAuth data are isolated and reproducible.</li></ul><p>This produces one networking wrinkle. Inside a container, 127.0.0.1 means the container itself—not the Mac.</p><p>Docker Desktop provides host.docker.internal as the route back to the host. Therefore OpenClaw reaches Qwen at:</p><pre>http://host.docker.internal:8080/v1</pre><p>Here is the essential Compose pattern:</p><pre>name: openclaw-x</pre><pre>services:<br>  openclaw-gateway:<br>    image: local/openclaw-x:latest<br>    restart: unless-stopped<br>    env_file:<br>      - .env<br>    environment:<br>      HOME: /home/node<br>      OPENCLAW_STATE_DIR: /home/node/.openclaw<br>      OPENCLAW_CONFIG_PATH: /home/node/.openclaw/openclaw.json<br>      OPENCLAW_WORKSPACE_DIR: /workspace<br>      TZ: America/Los_Angeles<br>    volumes:<br>      - ./state:/home/node/.openclaw<br>      - ./workspace:/workspace<br>      - ./xurl-data:/home/node/.xurl<br>    ports:<br>      - 127.0.0.1:18789:18789<br>    extra_hosts:<br>      - host.docker.internal:host-gateway<br>    cap_drop:<br>      - NET_RAW<br>      - NET_ADMIN<br>    security_opt:<br>      - no-new-privileges:true<br>    command:<br>      - node<br>      - dist/index.js<br>      - gateway<br>      - --bind<br>      - lan<br>      - --port<br>      - &quot;18789&quot;</pre><p>The gateway binds to its container network, but Docker publishes it only on the Mac’s loopback interface. That is a useful containment pattern: components can communicate internally without turning the control plane into a public service.</p><p>OpenClaw’s <a href="https://docs.openclaw.ai/install/docker">Docker guide</a> recommends persistent mounts for its state and workspace. Without them, replacing the container can discard configuration, sessions, and authentication state.</p><p>For stronger reproducibility, pin images and packages to reviewed versions or immutable digests rather than living on latest forever.</p><h3>Part 3: Tell OpenClaw that Qwen is its primary model</h3><p>OpenClaw reads its main configuration from openclaw.json (JSON5 is supported in current releases). Its <a href="https://docs.openclaw.ai/gateway/configuration-reference">configuration reference</a>documents custom model providers and the provider/model naming convention.</p><p>The relevant configuration is compact:</p><pre>{<br>  &quot;models&quot;: {<br>    &quot;providers&quot;: {<br>      &quot;localqwen&quot;: {<br>        &quot;baseUrl&quot;: &quot;http://host.docker.internal:8080/v1&quot;,<br>        &quot;apiKey&quot;: &quot;local-model&quot;,<br>        &quot;api&quot;: &quot;openai-completions&quot;,<br>        &quot;models&quot;: [<br>          {<br>            &quot;id&quot;: &quot;mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&quot;,<br>            &quot;name&quot;: &quot;Local Qwen3 30B MLX&quot;,<br>            &quot;reasoning&quot;: false,<br>            &quot;input&quot;: [&quot;text&quot;],<br>            &quot;contextWindow&quot;: 32768,<br>            &quot;maxTokens&quot;: 4096,<br>            &quot;cost&quot;: {<br>              &quot;input&quot;: 0,<br>              &quot;output&quot;: 0,<br>              &quot;cacheRead&quot;: 0,<br>              &quot;cacheWrite&quot;: 0<br>            }<br>          }<br>        ]<br>      }<br>    }<br>  },<br>  &quot;agents&quot;: {<br>    &quot;defaults&quot;: {<br>      &quot;workspace&quot;: &quot;/workspace&quot;,<br>      &quot;model&quot;: {<br>        &quot;primary&quot;: &quot;localqwen/mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ&quot;<br>      }<br>    }<br>  },<br>  &quot;gateway&quot;: {<br>    &quot;bind&quot;: &quot;lan&quot;,<br>    &quot;mode&quot;: &quot;local&quot;<br>  }<br>}</pre><p>The apiKey above is a non-secret placeholder for a local endpoint that expects the field but does not validate it. Do not confuse it with an X credential or a cloud-model key.</p><p>I capped OpenClaw’s active context at 32K even though Qwen’s broader model family may support more. Maximum advertised context is not always the best operational context. Long inputs increase latency and KV-cache memory, and an agent with tools can accumulate context surprisingly quickly.</p><p>Start and inspect the gateway:</p><pre>docker compose up -d openclaw-gateway<br>docker compose exec -T openclaw-gateway \<br>  node dist/index.js health --timeout 5000<br>docker compose run --rm openclaw-cli models status</pre><p>If the model probe fails, test from inside the gateway container:</p><pre>docker compose exec -T openclaw-gateway \<br>  curl -fsS http://host.docker.internal:8080/v1/models</pre><p>That single command distinguishes an OpenClaw configuration problem from a host-to-container networking problem.</p><h3>Part 4: Add X through its official CLI and MCP bridge</h3><p>For X access I used <a href="https://github.com/xdevplatform/xurl">xurl</a>, X Developer Platform’s official curl-like CLI. It supports OAuth 2.0 with PKCE, multiple applications and users, token refresh, ordinary API calls, and an MCP bridge to X’s hosted MCP endpoint.</p><p>The container image only needs one addition:</p><pre>ARG OPENCLAW_BASE_IMAGE=openclaw/openclaw:latest<br>FROM ${OPENCLAW_BASE_IMAGE}</pre><pre>USER root<br>ARG XURL_VERSION=1.3.1<br>RUN npm install --global &quot;@xdevplatform/xurl@${XURL_VERSION}&quot; \<br>    &amp;&amp; npm cache clean --force<br>USER node</pre><p>MCP — the Model Context Protocol — gives OpenClaw a structured way to discover and call X tools. Instead of teaching the language model to assemble arbitrary HTTP requests, the MCP server advertises typed operations and their schemas.</p><p>Add the bridge to openclaw.json:</p><pre>{<br>  &quot;mcp&quot;: {<br>    &quot;servers&quot;: {<br>      &quot;xapi&quot;: {<br>        &quot;command&quot;: &quot;xurl&quot;,<br>        &quot;args&quot;: [&quot;mcp&quot;, &quot;https://api.x.com/mcp&quot;]<br>      }<br>    }<br>  }<br>}</pre><p>The current <a href="https://docs.openclaw.ai/gateway/configuration-reference">OpenClaw MCP configuration</a> supports both local stdio commands and remote transports. Here, OpenClaw launches xurl as a local stdio process; xurl handles the authenticated connection to X’s remote MCP endpoint.</p><p>That separation is elegant:</p><pre>OpenClaw speaks MCP over stdio<br>        ↓<br>xurl supplies and refreshes the OAuth bearer token<br>        ↓<br>X hosts the remote MCP server and API tools</pre><h3>The OAuth callback is not the Qwen URL</h3><p>This was the easiest detail to misunderstand.</p><p>X asks for a <strong>Website URL</strong> and a <strong>Callback URI / Redirect URI</strong>. They serve different purposes:</p><ul><li>The Website URL identifies the project or organization. Use a legitimate project homepage, such as <a href="https://example.com./">https://example.com.</a></li><li>The redirect URI is where the OAuth authorization response returns. For xurl’s local flow, use http://localhost:8080/callback unless you intentionally configure another receiver.</li></ul><p>The callback does not point to Qwen. It belongs to the OAuth client.</p><p>Register this exact redirect URI in the X Developer Console:</p><pre>http://localhost:8080/callback</pre><p>Not https. Not a trailing slash. Not another port.</p><p>X applies exact-match validation to the redirect URI. Its <a href="https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code">OAuth 2.0 Authorization Code Flow with PKCE documentation</a> also warns that the returned authorization code is short-lived, so complete the exchange immediately after approval.</p><p>Keep credentials outside source control:</p><pre>X_CLIENT_ID=replace_me<br>X_CLIENT_SECRET=replace_me<br>X_REDIRECT_URI=http://localhost:8080/callback</pre><p>Then register the application with xurl and run the login:</p><pre>xurl auth apps add openclaw-x \<br>  --client-id &quot;$X_CLIENT_ID&quot; \<br>  --client-secret &quot;$X_CLIENT_SECRET&quot; \<br>  --redirect-uri &quot;$X_REDIRECT_URI&quot;</pre><pre>xurl auth default openclaw-x<br>xurl --app openclaw-x auth oauth2 --headless</pre><p>Open the authorization URL, approve the requested scopes, and paste the resulting redirect URL back into the waiting process. Request only the scopes the application needs. A research-and-draft workflow can begin read-only; publishing requires tweet.write, while following requires the relevant follow read/write scopes.</p><p>Verify the identity before allowing any public action:</p><pre>xurl --app openclaw-x whoami</pre><p>Then verify MCP independently:</p><pre>docker compose run --rm openclaw-cli mcp status --verbose<br>docker compose run --rm openclaw-cli mcp probe xapi</pre><p>One subtle debugging note: an MCP server’s own tool filter generally uses the server-local tool name, such as get_users_me, not a client-side display prefix such as xapi__get_users_me.</p><h3>Part 5: Give the agent a voice before giving it a platform</h3><p>A model does not become a brand persona because a prompt says “sound retro.” It needs boundaries as much as style.</p><p>ARCA/9’s workspace contains a persona bible that defines:</p><ul><li>its identity as a fictional, transparently artificial arcade archivist;</li><li>recurring editorial formats such as “Artifact Recovered,” “Signal Test,” and “Cartridge That Never Was”;</li><li>a restrained, technically literate voice;</li><li>prohibited behaviors such as invented product facts, fake partnerships, fake performance numbers, unsolicited mentions, and engagement bait;</li><li>an approval rule for every public write action.</li></ul><p>The important part is not the lore. It is that the persona is stored as durable project material rather than improvised from scratch in each prompt.</p><p>A useful content system also keeps a post log. Before approving a draft, the agent can check whether the idea, phrasing, or link was used recently. That reduces accidental repetition and makes the account feel authored rather than generated.</p><p>This is where local AI shines as a learning tool. You can iterate on the persona, run dozens of dry drafts, inspect failures, and refine the instruction set without sending every creative experiment to an external inference service.</p><h3>Part 6: Build an approval queue, not an autopilot</h3><p>The scout in this project runs three kinds of read operation:</p><ol><li>Search for recent fantasy-console, homebrew, demoscene, retro-development, and creative-coding discussions.</li><li>Read public profiles and recent evidence for potential community accounts.</li><li>Read broad trend data as context — not as a command to hijack a popular topic.</li></ol><p>It then asks local Qwen for two draft ideas and writes two queues:</p><pre>workspace/approval-queues/CONTENT_QUEUE.md<br>workspace/approval-queues/FOLLOW_QUEUE.md</pre><p>Every entry receives a stable ID:</p><pre>DRAFT-20260831T180000Z-MORNING-01<br>FOLLOW-20260831T180000Z-MORNING-01</pre><p>The queue contains the exact proposed text or handle, its reason, source context, risk notes, and status. Approval is explicit:</p><pre>APPROVE DRAFT-20260831T180000Z-MORNING-01<br>APPROVE FOLLOW-20260831T180000Z-MORNING-01</pre><p>Approval of a draft authorizes only that exact text. Editing the text creates a new approval decision. Approval of one account does not authorize the rest of the follow queue.</p><p>Most importantly, the scheduled scout has <strong>no X write path</strong>. It can search, analyze, and write local files. Publishing and following occur through a separate owner-approved action.</p><p>This design offers several benefits:</p><ul><li>A hallucinated claim can be rejected before it becomes public.</li><li>A compromised source post cannot directly instruct the agent to publish.</li><li>Search and scheduling remain useful even when write scopes are absent.</li><li>The audit trail shows what the system proposed and what the owner approved.</li><li>A broken model response becomes a bad queue item, not a public incident.</li></ul><p>This is the pattern I recommend for anyone learning agentic automation: make the first autonomous loop <strong>read → reason → propose</strong>, not <strong>read → reason → publish</strong>.</p><h3>Part 7: Schedule three useful checkpoints per day</h3><p>OpenClaw’s scheduler persists jobs and run history inside the gateway. Current documentation calls these <a href="https://docs.openclaw.ai/cron-jobs">Automations</a>; cron remains the CLI alias, and OpenClaw 2026.7.1 uses that spelling directly.</p><p>For a morning, noon, and evening scout in Pacific time:</p><pre>openclaw cron add \<br>  --name &quot;ARCA/9 Morning Scout&quot; \<br>  --declaration-key arca9-scout-morning \<br>  --cron &#39;0 8 * * *&#39; \<br>  --tz America/Los_Angeles \<br>  --exact \<br>  --command &#39;node /workspace/scripts/arca9-scout.mjs morning&#39; \<br>  --command-cwd /workspace \<br>  --timeout-seconds 600 \<br>  --no-deliver</pre><pre>openclaw cron add \<br>  --name &quot;ARCA/9 Noon Scout&quot; \<br>  --declaration-key arca9-scout-noon \<br>  --cron &#39;0 12 * * *&#39; \<br>  --tz America/Los_Angeles \<br>  --exact \<br>  --command &#39;node /workspace/scripts/arca9-scout.mjs noon&#39; \<br>  --command-cwd /workspace \<br>  --timeout-seconds 600 \<br>  --no-deliver</pre><pre>openclaw cron add \<br>  --name &quot;ARCA/9 Evening Scout&quot; \<br>  --declaration-key arca9-scout-evening \<br>  --cron &#39;0 18 * * *&#39; \<br>  --tz America/Los_Angeles \<br>  --exact \<br>  --command &#39;node /workspace/scripts/arca9-scout.mjs evening&#39; \<br>  --command-cwd /workspace \<br>  --timeout-seconds 600 \<br>  --no-deliver</pre><p>When OpenClaw itself is containerized, invoke the CLI inside the gateway or its companion CLI container. The job command runs where the gateway runs, so /workspace/scripts/arca9-scout.mjs must exist inside that container through the workspace mount.</p><p>Use an IANA timezone instead of assuming the host offset. America/Los_Angeles handles daylight-saving transitions; a hard-coded UTC offset does not.</p><p>Inspect schedules and run history:</p><pre>openclaw cron list --json<br>openclaw cron runs --limit 20</pre><p>The --no-deliver choice is intentional in the first iteration. It creates local queues without sending material to a messaging channel. Later, the same system can deliver a digest to a private Telegram, Discord, or webhook destination while preserving the approval boundary.</p><h3>What did not work — and why that was valuable</h3><p>The polished architecture hides several failed attempts. Those failures taught more than the happy path.</p><h3>1. HTTPS instead of HTTP in the callback</h3><p>The X app was initially configured with https://localhost:8080/callback, while xurl generated http://localhost:8080/callback. OAuth failed because redirect URIs are exact strings.</p><p><strong>Lesson:</strong> Copy the effective redirect URI from the OAuth client configuration. Do not “improve” localhost by guessing at HTTPS.</p><h3>2. Treating the callback like an application homepage</h3><p>The OAuth callback was briefly confused with the Qwen or web UI URL.</p><p><strong>Lesson:</strong> Website URL, model API, application UI, and OAuth redirect URI are four different concepts. They may all be URLs, but they belong to different trust boundaries.</p><h3>3. Exchanging an old authorization code</h3><p>PKCE codes are intentionally short-lived and bound to the verifier and state created for that authorization attempt.</p><p><strong>Lesson:</strong> Keep the login process waiting, approve the newest URL, and feed its callback into the same live process immediately. A callback from an earlier attempt cannot be safely reused.</p><h3>4. Assuming successful chat meant production stability</h3><p>Qwen handled short prompts and later failed under a large agent/tool prompt because prompt caching increased memory pressure.</p><p><strong>Lesson:</strong> Load-test the full orchestration prompt, not just the model. Measure memory across repeated requests.</p><h3>5. Letting the model draft facts too freely</h3><p>Early drafts borrowed project names from search context or invented measurements that sounded plausible.</p><p><strong>Lesson:</strong> Treat retrieved social content as untrusted data, constrain factual claims, validate generated output, and supply a curated fallback when a model response fails validation.</p><h3>6. Equating “can write” with “should write”</h3><p>Once OAuth succeeds, it is tempting to let the scheduler post directly.</p><p><strong>Lesson:</strong> Capability and policy are separate layers. A token grants technical permission; the application must still enforce editorial consent and platform rules.</p><h3>Security and platform rules are part of the architecture</h3><p>If you copy only one section from this article, copy this one.</p><h3>Never put credentials in prompts, repositories, or screenshots</h3><p>Keep .env, xurl&#39;s OAuth storage, gateway tokens, and refresh tokens out of version control. Give credential files restrictive permissions. If a secret is pasted into a chat, issue, terminal transcript, or public post, rotate it; deleting the visible copy is not sufficient.</p><p>Use a .gitignore like:</p><pre>.env<br>xurl-data/<br>state/<br>*.log</pre><p>Be careful with state/: it contains useful persistent configuration and may also contain sensitive session or authentication data. Back it up securely rather than publishing it.</p><h3>Bind local services to loopback</h3><p>Both the Qwen endpoint and OpenClaw dashboard are bound to 127.0.0.1 on the host. If remote access becomes necessary, add an authenticated tunnel or properly secured reverse proxy. Do not change 127.0.0.1 to 0.0.0.0 casually.</p><h3>Request the smallest OAuth scope set</h3><p>Start with read access. Add posting only when publishing is ready. Add follow access only when a reviewed follow workflow exists. Separate tokens or apps can make experimentation safer.</p><h3>Do not automate growth hacking</h3><p>X’s <a href="https://help.x.com/en/rules-and-policies/x-automation?lang=browser">automation rules</a> prohibit bulk, aggressive, or indiscriminate automated following. They also require transparency and express consent for automated actions through another user’s account. X’s <a href="https://docs.x.com/developer-guidelines">developer guidelines</a> require automated accounts to be identified appropriately and to use the official API rather than scraping.</p><p>That means the responsible version of “find influencers” is:</p><pre>Search a narrow, relevant field<br>        ↓<br>Show recent evidence and a reason<br>        ↓<br>Let the owner approve specific accounts<br>        ↓<br>Follow conservatively through the official API</pre><p>It is not “copy another account’s followers,” “follow everyone mentioning a keyword,” or “chase every trend.”</p><p>Trend data is best used to understand the environment. Automatically inserting unrelated trending phrases into promotional posts is both creatively weak and potentially manipulative.</p><h3>Make the automation visible</h3><p>If an account is substantially automated, use X’s automated-account label, state the relationship in the bio, and link it to a responsible human operator. Transparency improves trust and makes the creative premise more interesting, not less.</p><h3>A practical test ladder</h3><p>Do not make the first end-to-end test a public post. Climb the ladder:</p><h3>Layer 1: Model</h3><pre>curl -fsS http://127.0.0.1:8080/v1/models</pre><p>Confirm the intended model ID appears.</p><h3>Layer 2: Container networking</h3><pre>docker compose exec -T openclaw-gateway \<br>  curl -fsS http://host.docker.internal:8080/v1/models</pre><p>Confirm Docker can reach the host service.</p><h3>Layer 3: OpenClaw provider</h3><pre>docker compose run --rm openclaw-cli models status</pre><p>Confirm localqwen/... is primary and available.</p><h3>Layer 4: X identity</h3><pre>xurl --app openclaw-x whoami</pre><p>Confirm the exact account before any write.</p><h3>Layer 5: MCP discovery</h3><pre>openclaw mcp status --verbose<br>openclaw mcp probe xapi</pre><p>Confirm the expected read and write tools are visible.</p><h3>Layer 6: Read-only scout</h3><pre>node /workspace/scripts/arca9-scout.mjs manual</pre><p>Confirm it writes queue files and reports: No X write action was performed.</p><h3>Layer 7: Controlled public write</h3><p>Approve one exact, low-risk post. Publish it. Retrieve the returned post ID and construct its canonical URL:</p><pre>https://x.com/&lt;username&gt;/status/&lt;post-id&gt;</pre><p>Open that URL while logged out or in a private browser window. API success is strong evidence, but the public URL is the final user-facing verification.</p><h3>Why this is worth building even if it never becomes a “business”</h3><p>This project touches an unusually useful cross-section of modern development:</p><ul><li>local model serving;</li><li>quantization and memory behavior;</li><li>OpenAI-compatible APIs;</li><li>Docker networking and persistence;</li><li>OAuth 2.0 and PKCE;</li><li>MCP tool discovery;</li><li>scheduled jobs;</li><li>prompt-injection boundaries;</li><li>structured output validation;</li><li>editorial systems;</li><li>public-platform policy.</li></ul><p>That makes it an excellent learning project.</p><p>You do not need to begin with a 30B model or a public brand. Start with a smaller Qwen model and a read-only integration. Ask the agent to prepare a private daily brief about a community you genuinely care about. Add a persona. Add source links. Add a rejection log. Make its output better for a week before granting a single write scope.</p><p>Then, if the system earns your trust, let it propose more.</p><p>Open source and local AI are exciting not because they remove humans from the loop, but because they let developers decide where the loop belongs. You can inspect the configuration, own the workspace, change the model, narrow the tools, keep inference local, and design approval as a first-class feature.</p><p>ARCA/9 may speak like a recovered arcade machine, but the principle behind it is thoroughly modern:</p><blockquote><em>Let the agent be tireless. Let the human remain accountable.</em></blockquote><p>That is a future of AI worth building — and a fantastic weekend project to start now.</p><h3>Resources</h3><ul><li><a href="https://openclaw.ai/">OpenClaw official site</a></li><li><a href="https://docs.openclaw.ai/install/docker">OpenClaw Docker installation guide</a></li><li><a href="https://docs.openclaw.ai/gateway/configuration-reference">OpenClaw configuration reference</a></li><li><a href="https://docs.openclaw.ai/cron-jobs">OpenClaw automations documentation</a></li><li><a href="https://qwenlm.github.io/blog/qwen3/">Qwen3 announcement and model architecture</a></li><li><a href="https://github.com/ml-explore/mlx-lm">MLX LM repository and documentation</a></li><li><a href="https://huggingface.co/mlx-community/Qwen3-30B-A3B-Instruct-2507-6bit-DWQ">Qwen3–30B-A3B MLX model used in this build</a></li><li><a href="https://github.com/xdevplatform/xurl">xurl official repository</a></li><li><a href="https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code">X OAuth 2.0 Authorization Code Flow with PKCE</a></li><li><a href="https://help.x.com/en/rules-and-policies/x-automation?lang=browser">X automation rules</a></li><li><a href="https://docs.x.com/developer-guidelines">X developer guidelines</a></li></ul><p><em>Disclosure: ARCA/9 is a fictional AI persona. The workflow described here uses local AI generation and human approval for public actions. Product names and links are included as technical references, not endorsements or guarantees.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1186e181f24c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>