No-Code Agentist

hermes agent/nous research/a new ai model Tencent Hy3/agent doing compelete install of hermes desktop in windows wsl no human intervention/agent doing full debugging of its environemnt and fixing it by itself. This goes beyong coding. all done through simple text prompt. When a New AI Model Tencent's Hunyuan 3 Solved a Problem That Conventional Debugging Could Not Artificial intelligence has become remarkably good at writing code. Every few months another benchmark appears, another model climbs the leaderboard, and another company announces that its latest release is smarter, faster, or more capable than the last. Those benchmarks are useful, but they rarely answer the question that most engineers eventually ask: what happens when an AI is given a real system, a real problem, and enough freedom to investigate it? I was starting up an environment to evaluate Tencent's Hunyuan 3 model through the Hermes Agent framework. Hermes had already become an important part of my daily workflow. My development environment spans Windows 10, WSL2, multiple Linux systems, Docker, Android devices, SSH, and tmux. Most of my work is performed remotely from a tablet over SSH, so the command line is where I spend most of my time. Hermes fit naturally into that environment because it provided a common interface for running different AI models while also acting as an autonomous agent capable of interacting with the underlying operating system. Over months of use, Hermes proved itself to be remarkably reliable. The command-line interface became my preferred way of working. Agents executed correctly, boards and workspaces behaved as expected, models switched effortlessly, and automation became part of my everyday routine. The web dashboard was simply another interface layered on top of a system that had already earned my confidence. Then, without warning, the dashboard stopped working. The command I had typed countless times suddenly produced a completely different result. Instead of opening the dashboard, the browser entered an OAuth authentication flow that never completed. Nothing crashed. Nothing produced an obvious error. The login simply hung. Like most engineers, I assumed the problem was somewhere in the configuration. I checked authentication settings, reviewed configuration files, examined environment variables, verified ports, searched logs, and experimented with different startup options. The problem looked exactly like the kind of issue that eventually yields to persistence. It didn't. What made the situation particularly confusing was that Hermes itself had never actually failed. Throughout the entire investigation the command-line interface continued working exactly as before. Agents executed normally. Models loaded correctly. Boards worked. Workspaces worked. Automation never missed a beat. The only component exhibiting any abnormal behaviour was the dashboard itself. That realization changed the entire investigation. Instead of asking what was wrong with Hermes, the question became much narrower: why was one small part of an otherwise healthy system behaving differently? Around the same time I decided to evaluate Tencent's Hunyuan 3 model through the Nous Research platform. Outside China, Tencent's language models receive far less attention than those from OpenAI, Anthropic, Google, or Meta, making them particularly interesting to evaluate from an engineering perspective. The version I was using was Tencent's Hunyuan 3 through the Nous Research endpoint `tencent/hy3:free`. Hy3 is a 295B-parameter Mixture-of-Experts model from Tencent (21B active, 192 experts with top-8 routing) built for reasoning, agentic workflows, and real-world production use. It supports a configurable reasoning effort: a direct no-think mode by default, plus low and high chain-of-thought modes for complex math, coding, and multi-step problems. With a 256K context window, Hy3 targets long-horizon tasks, including improved coreference resolution, multi-turn constraint tracking, and stable tool-calling that generalizes across agent scaffoldings. Tencent positions it as a reliable, cost-effective option across coding, document processing, financial analysis, game development, and frontend design, with a strong emphasis on grounded, anti-hallucination behavior that answers when grounded and flags when evidence is missing rather than fabricating. Ironically, before I could evaluate the model itself, I encountered another obstacle. Accessing Hunyuan required authentication through the Nous Research portal. That sounds trivial until your normal computing environment consists almost entirely of WSL, Linux terminals, Android Termux, and SSH sessions. Eventually I had to return to a Windows desktop simply to complete the browser-based authentication process before I could continue using the model from my preferred terminal workflow. It was a reminder that while AI models increasingly live comfortably inside command-line environments, much of the surrounding infrastructure still assumes a traditional desktop user. Once Hunyuan became available inside Hermes, I decided to give it something far more interesting than a benchmark or programming exercise. I gave it the same engineering problem that had already consumed a significant amount of debugging effort. This is where the experience became genuinely surprising. I have relied heavily on ChatGPT throughout this entire project. It has helped me understand WSL, Linux internals, Docker, networking, distributed development, Electron, and countless other technologies. Much of the environment I use today was built with its assistance, and it remains one of the most valuable learning tools I have ever used. However, this particular problem proved unusually specific. Despite multiple debugging sessions, we never arrived at a working solution. Hunyuan approached the same problem differently. Instead of repeatedly proposing configuration changes, it began investigating the running system itself. It inspected the installation, examined source code, analysed running processes, verified assumptions against the live environment, modified configuration files when necessary, tested each change, discarded hypotheses that no longer matched the evidence, and continued iterating until the system behaved correctly. The first accomplishment came before the dashboard problem was even solved. Getting Hermes Desktop running under Windows through WSL turned out to be considerably more involved than installing a conventional desktop application. Hermes Desktop is an Electron application executing inside WSL while displaying its graphical interface through WSLg on the Windows desktop. Launching it successfully requires understanding Electron, Linux permissions, sandboxing, WSL integration, environment variables, and Hermes' own startup sequence. What impressed me was not that Hunyuan explained how Hermes Desktop worked. It actually stood the system up. Working through the Hermes agent framework, it inspected the existing installation, analysed the startup process, adjusted the runtime environment, modified the necessary configuration, resolved launch problems, verified each stage, and finally started Hermes Desktop successfully. At no point did I have to manually edit configuration files, experiment with launch options, or drive the troubleshooting process myself. The installation, configuration, and launch sequence were completed autonomously by the agent. That alone would have made the evaluation worthwhile. The Hermes dashboard problem proved even more interesting. The investigation revolved around authentication providers, OAuth settings, browser behaviour, Windows networking, WSL networking, firewall rules, port forwarding, configuration files, and environment variables. Every explanation sounded reasonable. None explained the behaviour of the running system. Eventually Hunyuan stopped treating the issue as a configuration problem and started treating it as an architectural one. The dashboard itself was never fundamentally broken. The problem was the interaction between Hermes' authentication model, Windows localhost forwarding, WSL2's virtual networking, Linux loopback interfaces, Windows port forwarding, and the way Hermes distinguishes between loopback and non-loopback connections. Individually, every component behaved correctly. Together they produced a failure that was remarkably difficult to diagnose. The complete engineering analysis is documented separately because it deserves its own technical discussion. Once the architecture became clear, the solution was elegant. Hermes remained bound to the Linux loopback interface, preserving its intended authentication behaviour. A lightweight relay bridged the WSL virtual interface back to loopback, while Windows forwarded browser traffic into the correct location inside WSL. Within minutes the dashboard loaded normally, authentication loops disappeared, and the environment returned to a stable, working state. Looking back, what impressed me was not simply that Hunyuan found the answer. Engineers solve difficult problems every day. What impressed me was the process. Working through Hermes, the model behaved less like a chatbot and more like a systems engineer. It investigated the environment, modified live configuration, launched applications, verified runtime behaviour, corrected incorrect assumptions, and continued until both major objectives had been achieved. First, it successfully installed, configured, and launched Hermes Desktop under WSL with essentially no human intervention. Second, it diagnosed and repaired a complex dashboard failure involving Windows, WSL2, networking, authentication, and Linux services. Both accomplishments were verified against a live system rather than accepted because they sounded plausible. Those two tasks are, in my view, far more meaningful than benchmark scores or coding puzzles. They represent the kind of work infrastructure engineers perform every day: understanding unfamiliar systems, isolating failures, making carefully considered changes, testing them against reality, and continuing until the system is genuinely operational. I am not suggesting that one language model is universally better than another. That would be an unreasonable conclusion from a single project. What I can say, based entirely on direct experience, is much narrower and much more defensible. For this particular engineering problem, ChatGPT did not reach a working solution. Tencent's Hunyuan 3, operating through the Hermes agent framework, did. That observation says as much about the importance of agent frameworks as it does about the underlying model. Hermes provided the tools to inspect the environment, execute commands, edit files, launch applications, and verify results. Hunyuan supplied the reasoning that drove those tools. The combination produced something that felt fundamentally different from a conversational assistant. It felt like collaborating with an engineer capable of working directly on a live software system. For years we have talked about AI writing code. This experience suggested that the more interesting future may not be code generation at all. It may be AI systems capable of investigating, configuring, validating, and repairing complex software environments with minimal human intervention. If that future has already begun, then this was the first time I had the opportunity to watch it happen on my own machines.

I don't use AI in a private chat window anymore. my whole marketing team at @0xPolygon shares one agent that lives in our Slack. we named her Polly. 6 weeks in, I do most of my job by talking to her in channels the whole team can see. This is not a new concept, most notably this was made popular by @tobi's article "learning on the shop floor" and their agent, River. Anthropic just released Claude Tag and admitted 65% of the product team's code comes from their Tag instance. But I haven't seen many marketers talk about it so here is what I've learned and how my team has adapted: 1. Working in public with an agent is awkward -- it's like having someone watch you type a Google search. This was the single biggest barrier to adoption. But you get more comfortable the more you do it and see others doing it. it's extra loaded in marketing, where so much of the job runs on taste. nobody wants their messy first prompt judged by the same people who judge their finished work. 2. Adoption has to come from everyone (including me) I can’t push the marketing team to work in public if I wasn't doing it myself. So I made it a rule: always try Polly first, in channel, where others can see. I still use wispr flow and half-baked prompts. my team gets to see how I actually think through a problem without me narrating it. and once they watched me do it badly in public, they stopped being scared to. 3. Collaboration is the real unlock When you work with a shared agent in a channel, other people can jump in, suggest edits, and learn what's possible. That's the flywheel. Everyone upskills around you just by watching. I've learned a lot from watching others work this way, too. I can drop into their threads and suggest things without waiting for a 1:1. What this means is marketing orgs are getting flatter. The ability to execute stopped being locked to whoever owned the skill. the strategist can get a real design first draft. someone who's never written ad copy can ship something on brand. everyone picked up a chunk of execution they didn't have before. we move way faster now. the work compounds in public instead of dying in someone's private chat window. bottlenecks have been disappearing. 4. Domain-specific channels beat one mega-channel We still have one general channel for misc use, but we've built out domain-specific ones (polly-social, polly-comarketing, polly-ads, polly-diana, etc.) We also give Polly access to our existing working channels so we can call on her in context. Reduces context-switching and makes past conversations findable. 5. This is already extending beyond marketing we recently shipped a skill specifically designed for BD. We're rolling it out to other teams next. and of course we have other agents working across other teams (data, eng, product) that it is collaborating with. 6. "Why not just use Claude Desktop?" This was a common question. Here's what tipped the scale for us: > Shared skills — When one person's correction improves a skill, everyone benefits on their next output. No re-sharing or re-downloading. The agent always has the most up-to-date version. > Shared connectors — Polly has access to tools that not everyone has individual seats for. One agent's access becomes the team's access. > Shared context — Multiple times this month, someone was out and a teammate picked up where they left off with a simple tag in a thread. Polly also catches things like conflicting campaign dates across workstreams. > It's where we already work — No app-switching. 90% of my day is in Slack now. Works on mobile. And you can close your laptop and it keeps running! TLDR: Using a shared agent takes time to see how the value compounds. But it's well worth the effort and has fundamentally changed how our team operates! btw, Polly was built by the amazing @leonstern so you should chat with him if it's something you are interested in. I'm next going to share our favorite workflows, automations, loops, and skills. so stay tuned!

THIS VIDEO SHOWS HOW TO BUILD THREE AI AGENTS IN CLAUDE WITH ZERO CODE. Each one wipes out a task people still grind through by hand. A research agent fires one prompt into a finished 2,000-word article. A file agent devours a whole folder and fuses it into one master doc. A morning agent drops a briefing in your inbox on schedule. The real value: none of it needs a developer, an API, or a paid tool on top. > research agent — one prompt to a full article > file agent — summarizes a folder of PDFs into one doc > morning agent — 7am Gmail and calendar briefing > all built in plain English, no code The point is not the model. It is that these workflows are now copy-paste simple. This is the playbook every solo builder is about to run. Follow me so you don't miss out on trends in the world of AI.