No-Code Agentist

I spent 12 hours this weekend installing https://t.co/aq7DBz7en5 on every agent. here's everything i learned: → claude chat - 90% of the world uses this or chatgpt. It loves MCPs. And it's great for one-shot tasks (headline generator, find journalists), but it can't run the complex scheduled workflows. big gap to to solve for here. → claude cowork - positioned as "claude code for business," but in practice it's stripped down with more limitations than i expected. everything sandboxed and you can't persist to local machines easily. → local agents (claude code, codex, hermes, openclaw) - These agents love CLIs. and they have full coverage. real workflow orchestration. scheduled runs that actually persist. where most of the power users' agents live today. → chatgpt - the worst experience for skill-based workflows lol. skills are still gated to business and enterprise plans, so plus/pro users can't load newsjack natively yet I just shipped Newsjack v0.1.11 based on all these learnings: - rewrote the install flow for every platform with this giant matrix. - install to Claude and Cowork as a Claude plugin. - one-line install for local agents now works on Windows. - a rewritten getting-started guide for the agent to follow. - medialyst connection now uses a clean API endpoint the punchline: you no longer need to read the setup guide. paste this prompt into the AI agent of your choice: > "install https://t.co/5ViWqne7gA for me" agent reads the setup guide. detects your platform. picks the right install path. walk you through the whole setup. welcome to the world of agent onboarding - this is now the minimum bar every product is expected to clear.

The "Mixture of Models" approach is punching way above its weight class... OpenRouter launches Fusion, a tool that blends multiple AI models to beat frontier performance @OpenRouter dropped Fusion in beta, and it completely reframes how we look at LLM performance. Instead of waiting for a single, massive model upgrade, Fusion blends multiple models together to beat frontier performance today. Think of it as an instant AI panel discussion. It routes your prompt to a panel of distinct models, passes their outputs to a "judge" model, maps the consensus points, contradictions, and blind spots, and delivers one deeply cross-examined response. The benchmark data (tested on Perplexity’s grueling DRACO deep-research benchmark) tells an incredible story about where engineering is heading: Budget Panels Punch Up: A trio of cheaper models (Gemini 3 Flash + Kimi K2.6 + DeepSeek V4 Pro) scored 64.7%, comfortably beating solo giants like GPT-5.5 (60.0%) and Claude Opus 4.8 (58.8%). The Meta-Analysis Leap: Fusing a model with itself (running Opus multiple times with an Opus synthesizer) jumped its score by nearly 7%. The magic isn't just in the data; it’s in forcing the system to cross-examine different reasoning paths. Fusing Beats the Best Solo Models: A panel combining Fable 5 and GPT-5.5 outperformed Fable 5 running completely solo. The shift is clear: The immediate future of AI isn’t just about waiting for better weights from a single lab. It’s about orchestration, evidence synthesis, and meta-analysis. Yes, it’s 2x–3x slower. No, you wouldn’t use it for a simple code syntax check. But as a server-side tool that your primary agent can "call in" when it hits a complex architectural roadblock? It’s a game-changer. We are moving fast from a world of "prompting a model" to "managing a digital panel of experts." Are you looking at multi-model synthesis for your workflows yet, or are you still relying on a single champion LLM? Let's discuss in the comments. https://t.co/TTy9mzPsTV

Most AI agents don’t fail because the model is weak. They fail because their memory is poorly designed: too much noise in context, too few useful details, and no reliable path to rare tasks. A vertical agent works when its context is structured like a cache. A vertical agent is built for a specific class of work: spreadsheets, finance, sales, legal docs, DevOps. Its job is to win where the user can immediately tell the difference between “almost right” and “right.” The basic loop is now familiar: the model calls tools, reads the results, and continues until the task is done. That part can be built quickly. The hard part is everything around the model: designing context so the agent doesn’t drown in irrelevant information or start guessing. A good agent is a precise compression of the task distribution. Frequent operations should be close and cheap. Rare ones should not pollute every request, but must remain reachable. The right mental model is a multi-level cache. L1 is always in context. It covers the everyday 80%: core operations, key types, read/write rules, safety constraints. L1 must be compressed aggressively, because every extra token is paid for in every session. L2 is loaded on demand. It holds important but less frequent workflows: pivot tables, charts, conditional formatting, validation rules. The agent loads a short curated spec only when it actually needs it. L3 is the full raw reference. It can be huge and ugly, but it must be complete. Next to it, the agent needs a search skill: how to find methods, types, enums, and rare capabilities. This prevents the agent from inventing APIs. For many vertical agents, one executable tool works better than dozens of tiny tools. The model writes code. The code calls the API. Less tool-choice noise means fewer wrong turns. The most common operations deserve the most engineering. For example, reading a spreadsheet should expose meaning: headers, formulas, styles, nearby context. Writing should not return a wall of changes. It should return a compressed diff: what changed, what was risky, and what needs review. The recipe is simple: L1 — frequent things nearby. L2 — important things on demand. L3 — rare things, still reachable. A vertical agent does not become strong through magic architecture. It becomes strong when its context behaves like memory: common things are effortless, rare things are findable, and irrelevant things stay out of the way.