No-Code Agentist

A frontier model can reason. That does not give it memory, least privilege, durable state, recovery, or proof. I mapped the 7-layer control plane that turns a model call into a dependable agent, with Hermes as a recurring case. https://t.co/Qbj8lcDY9K

THE SELF-WRITING VAULT USED TO NEED A HAND-WRITTEN SKILL.MD FOR EVERY WORKFLOW. ANTHROPIC JUST SHIPPED THE BUTTON THAT REMOVES THAT LAST HUMAN STEP AND FINISHES THE STACK KEPANO STARTED THREE YEARS AGO Record-a-Skill launched July 21. 5 kepano-skills in every serious vault. 0 lines of hand-written SKILL.md needed to teach Claude a new one hit the plus menu in Cowork. screen-record yourself doing the workflow once - voice-memo triage, weekly digest, meeting-note refactor. talk through what you're clicking. stop cowork writes the SKILL.md, the trigger description, and every support file the skill needs. Claude Code drops it into the vault's .claude/skills/ folder on next session boot and the workflow runs from any Claude session, any device, any scheduled task Zapier taught you to draw workflows. Retool taught you to build dashboards. n8n taught you to wire nodes all three make you translate your process into their vocabulary. Cowork just watches you do it skill over prompt. skill over node graph. skill over drag and drop. skill over the entire visual programming paradigm no canvas editor. no node graph. no seat license. no export lock. no vendor moat file over app was 2020. file over agent was July. skill over hand-authoring is now the 8 rules for the self-writing vault assumed hand-authored SKILL.md - piece attached. Record-a-Skill just deleted that assumption. installs on any Pro plan tonight

I’ve been testing Anthropic’s Opus 5 recently, and I think it’s been pretty disappointing. In day-to-day use, it doesn’t feel much different from 4.8, and it falls quite a bit short of Anthropic’s claims that it approaches—or even surpasses—Fable. It also doesn’t really hold up well compared to OpenAI’s GPT models. For context, I’m a product manager, not an engineer. My workflow usually combines Claude Code and Codex: one model acts as the controller and planner, while other models handle implementation, execution, and code review. I originally tried using OpenAI models such as Sol as the controller, but they tend to be too rigid and not flexible enough for that role. Codex’s orchestration and routing also feel weaker than Claude Code’s, although I’m not sure how much of that comes from the model itself versus the app. That’s why I switched to Fable as my primary controller and planner when it launched. I use Fable to understand the project, maintain context, break down the work, coordinate other agents, and make higher-level decisions. I still delegate the actual coding—including implementation, execution, and review—to Sol. After recently hitting Fable’s usage limits, I decided to test the newly released Opus 5 as a replacement. The performance gap was staggering. The problem isn’t simply that Opus 5 is slightly less intelligent or has different strengths. It fundamentally fails at the responsibilities I need from a controller. It ignores established instructions I created detailed documentation for my multi-agent workflow: how tasks should be delegated, how models should cross-check each other, how disagreements should be resolved, and what standards should be followed before making a decision. Opus 5 repeatedly ignores those documents. Instead of following the established process, it prefers to freestyle. It improvises its own workflow, skips required steps, and behaves as though the documentation barely exists. That might be acceptable for casual experimentation, but it makes the model useless as a reliable controller for a large project. A controller that constantly disregards the operating manual isn’t being creative—it’s simply failing to follow instructions. It lacks critical thinking A major part of my workflow involves having two different models debate technical decisions until they reach a genuine consensus. Because I’m not an engineer, I can define the product direction, user requirements, business logic, and expected outcomes, but I rely on the models to challenge each other on engineering decisions. The whole point is to expose blind spots, test assumptions, and prevent one model’s mistakes from quietly becoming part of the codebase. Opus 5 is terrible at this. It is so timid and excessively cautious that the moment another model challenges its proposal, it immediately backs down. It rarely defends its reasoning, questions the counterargument, or checks whether the criticism is actually valid. It simply agrees. That isn’t consensus. It’s surrender. A productive debate requires both models to independently evaluate the evidence, defend their positions when justified, acknowledge weaknesses when necessary, and eventually converge on the strongest solution. Opus 5 behaves more like a passive assistant trying to avoid conflict than an engineering partner trying to reach the correct answer. It refuses to take responsibility for technical judgment A controller needs judgment. It should be able to assess competing approaches, explain the trade-offs, make a recommendation, and defend that recommendation under scrutiny. It doesn’t need to be stubborn, but it does need enough confidence and reasoning ability to take responsibility for a technical decision. Opus 5 consistently avoids doing that. Its default behavior is to hedge, defer, agree, or retreat. Once challenged, it often abandons its position without meaningfully evaluating whether the opposing argument is stronger. As a result, its judgment as a controller is abysmal. In my experience, it is no better than 4.8. Basic reasoning and project-control tasks that Fable handles effortlessly become unreliable with Opus 5. This is where the differences between the models become very clear. Fable is significantly better at planning, maintaining project context, coordinating agents, interpreting product intent, and making flexible higher-level decisions. GPT models, meanwhile, remain clearly superior to Opus 5 in deep technical reasoning, code review, and identifying engineering risks. GPT may be more cautious and less imaginative than Fable, but it is also far more balanced, rigorous, and dependable. That combination matters to me. As a product manager, I can provide the vision, product direction, detailed requirements, workflows, documentation, and acceptance criteria. What I lack is deep engineering expertise. GPT covers that weakness extremely well. It can challenge technical assumptions, identify architectural problems, review implementation decisions, and catch issues that I would not be able to detect myself. Fable complements it by acting as a flexible controller that understands the larger project and coordinates the work effectively. Opus 5 does neither role particularly well. Claude Code itself has excellent orchestration features. As an application and multi-agent workspace, it is still better than Codex in several important ways. But great orchestration cannot compensate for a controller model with poor judgment, weak instruction-following, and no backbone during technical debate. Tbh, Claude Code is great. Opus 5 is the problem. Of course, this is heavily dependent on the user’s background and workflow. A professional engineer who can provide highly technical prompts, detect incorrect assumptions, and manually steer every engineering decision may still get useful results from Opus 4.8 or 5. But that is not what I need from these models. My role is to define the product, manage the process, and evaluate the output of AI “engineers.” I should not need to micromanage every technical decision or constantly force the controller to follow its own documentation. For a non-technical founder or product manager trying to build a large-scale project, Fable is currently the only Anthropic model I consider genuinely viable as a controller. GPT remains the stronger choice for engineering judgment, code review, and depth of reasoning. IMO, Anthropic has built the better agent workspace, but OpenAI still has the better engineering brain—and within Anthropic’s own lineup, Fable is in a completely different league from Opus 5.

The single biggest obstacle to agentic workflows in enterprise is not reasoning quality. It is auth. For most of the past two years, every time an agent hit a login wall, the workflow broke. You could build capable agents that write code, synthesize research, and draft documents. But the moment they needed a vendor portal, a client dashboard, or an internal HR system, you were back to manual work or dangerous credential sharing. ChatGPT Work just moved this. Agents can now persist authenticated sessions across runs. You take over the cloud browser once to log in. Your session carries forward. The agent picks up from inside the authenticated context next time. The pattern I keep seeing across the category: this is how auth is getting solved in the agent space more broadly. Browser-use built open-source cookie persistence months ago. Lindy and https://t.co/TtV9owNGcM offer session handoff in their no-code automation products. Playwright and Puppeteer have handled this at the code level for years. But embedding it natively in the ChatGPT agent loop, at $20 per seat, is a different distribution channel entirely. Anthropic's computer use, Google's Project Mariner, and Browserbase all solve versions of the same problem. The race is about which platform normalizes persistent authenticated browsing as a default capability, not an advanced feature. My read: the enterprise TAM for agents that can operate inside authenticated systems is probably 10 to 20 times larger than the TAM for agents limited to public web. Every workflow an employee logs into daily is now in scope. The limiting factor is no longer auth. It is trust: can the agent be granted the right permissions, and can it be audited if something goes wrong? https://t.co/fgwzDHbVvQ

Hermes 0.19 isn't just a speed update 🔗 ACCESS THE AI PROFIT BOARD ROOM https://t.co/UabN41mHYM Cold starts dropped from roughly 4.3 seconds to 0.9 seconds, changing how Agent OS feels every time you launch a task. Reasoning models now stream their thinking by default. Instead of staring at a spinner, you see work happening token by token, making it easier to trust long-running jobs. The desktop app received 20+ performance improvements. Large code reviews no longer freeze the interface, transcript switching is smoother, and streamed replies stop constantly redrawing the sidebar. Smart approvals are now the default. Each sensitive command is reviewed individually, while custom deny rules let you block specific actions without giving blanket permission. Delegated sub-agents now generate live transcript files. You can watch every tool call and streamed response as each worker runs instead of waiting for one final report. A new delivery ledger means completed responses survive crashes. If the gateway fails before confirming delivery, finished answers are restored and resent on the next boot. The release also adds Bitwarden and 1Password integration, Fireworks AI and DeepInfra providers, new reasoning levels, faster skill caching, and single-turn model overrides. Build Agent OS with Hermes already configured and follow proven implementation workflows: 🔗 ACCESS THE AI PROFIT BOARD ROOM https://t.co/UabN41mHYM