Anthropic provides a public repository of skills designed to enhance Claude's performance on specialized, repeatable tasks by dynamically loading instructions and scripts. These skills allow the model to master complex workflows such as branding adherence, data analysis, document creation, and technical development through self-contained folders containing markdown metadata.
- Skills are implemented using `SKILL.md` files with YAML frontmatter for name and description.
- The repository includes source-available (not open source) skills used in production for PDF, DOCX, PPTX, and XLSX document creation.
- Users can install these skills via Claude Code as plugins or use them through the Claude API and web interface.
- A separate "Agent Skills" specification is available at agentskills.io to standardize agent capabilities.
- Skills are implemented using `SKILL.md` files with YAML frontmatter for name and description.
- The repository includes source-available (not open source) skills used in production for PDF, DOCX, PPTX, and XLSX document creation.
- Users can install these skills via Claude Code as plugins or use them through the Claude API and web interface.
- A separate "Agent Skills" specification is available at agentskills.io to standardize agent capabilities.
Anurag Singh writes about combining Claude Code's Auto mode with deny rules and ask rules to eliminate the need to manually approve every command. The setup lets Claude Code work uninterrupted in the background while hard-blocking destructive commands like force-pushes and rm -rf, and optionally prompting on risky-but-acceptable actions like git push.
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
- Deny rules are enforced by Claude Code itself rather than being instructions to the model, so they hold even in bypassPermissions mode
- A deny list can never be exhaustive; Claude could accomplish the same destructive action through a different tool (e.g., Python instead of rm)
- The built-in sandbox is a stronger safety net than any deny list, though it becomes tedious for projects depending on local databases, Docker, or private registries
- Permission rules are evaluated in fixed priority order: deny first, then ask, then allow
Max Liu writes about how agent-driven application scaling creates an "idle cost trap" where the economics of persistence break down because agents create far more database instances than are ever active. Using Kimi (Moonshot AI's platform) as a case study, he argues that separating durable state from ephemeral compute is the key architectural move, applied in two places: the tenant databases agents provision for end users and the agent's own workspace that must survive between maintenance sessions.
- Kimi provisions a new tenant database in ~1 second using a warm pool of pre-initialized resources
- Standardizing on a unified data layer improved the agent's code generation success rates, making database choice a "quality input" rather than just an infrastructure decision
- The four properties required simultaneously: tenant isolation, instant provisioning, cost elasticity, and persistent state independent of compute
- Sponsored post by PingCAP (TiDB)
- Kimi provisions a new tenant database in ~1 second using a warm pool of pre-initialized resources
- Standardizing on a unified data layer improved the agent's code generation success rates, making database choice a "quality input" rather than just an infrastructure decision
- The four properties required simultaneously: tenant isolation, instant provisioning, cost elasticity, and persistent state independent of compute
- Sponsored post by PingCAP (TiDB)
Imran Hassanali presents a comprehensive benchmark comparing "Code Mode"—where an LLM generates complete code to execute tools—against traditional function calling for tool interactions. The results demonstrate that Code Mode is significantly more efficient, achieving 60% faster execution, 68% fewer tokens used, and an 87.5% reduction in API round trips while maintaining equal accuracy compared to regular agents.
- Evaluated using eight realistic business scenarios, including multi-client invoicing and expense tracking.
- Code Mode advantage scales with task complexity; high-complexity tasks saw up to a 79.2% speedup.
- The benchmark tested both Claude 3 Haiku (showing major efficiency gains) and Gemini 2.0 Flash Experimental.
- Secure code execution is implemented via RestrictedPython, preventing filesystem and network access during the sandbox phase.
- Evaluated using eight realistic business scenarios, including multi-client invoicing and expense tracking.
- Code Mode advantage scales with task complexity; high-complexity tasks saw up to a 79.2% speedup.
- The benchmark tested both Claude 3 Haiku (showing major efficiency gains) and Gemini 2.0 Flash Experimental.
- Secure code execution is implemented via RestrictedPython, preventing filesystem and network access during the sandbox phase.
Wes Steyn writes that making an AI agent production-ready requires addressing observability, governance, deployment, and evaluation through a shared agent factory pattern. By defining the agent once in a single factory, developers can deploy the same core logic across different hosts—such as interactive consoles, hosted services on Foundry, or automated eval runners—while applying specific security constraints like disabling shell access for cloud environments.
- Observability is achieved via OpenTelemetry to track model turns, tool calls, and token usage.
- Microsoft Purview can be integrated via middleware to screen prompts and responses against organizational policies.
- Hosted agents in Foundry automatically handle telemetry configuration through environment variables.
- Local evaluations use simple functions for quick checks, while hosted evals provide model-graded quality scores like relevance and coherence.
- Observability is achieved via OpenTelemetry to track model turns, tool calls, and token usage.
- Microsoft Purview can be integrated via middleware to screen prompts and responses against organizational policies.
- Hosted agents in Foundry automatically handle telemetry configuration through environment variables.
- Local evaluations use simple functions for quick checks, while hosted evals provide model-graded quality scores like relevance and coherence.
- **Inference** – Platforms and engines for running models, plus user interfaces.
- **Models** – LLMs (general, coding, multimodal, image, audio), model providers, and specific model highlights.
- **RAG** – Retrieval-Augmented Generation tools.
- **Safeguards** – Safety and content filtering.
- **Agents & Tools** – Agent frameworks, Model Context Protocol, coding agents, computer/browser automation, memory management, and testing/evaluation.
- **Research, Training & Fine-tuning** – Security, sandboxing, and model development.
- **Hardware** – Local hardware options.
- **Tutorials** – Guides covering models, prompt/context engineering, inference, agents, and RAG.
- **Communities** – Places to connect and share knowledge.
- **Models** – LLMs (general, coding, multimodal, image, audio), model providers, and specific model highlights.
- **RAG** – Retrieval-Augmented Generation tools.
- **Safeguards** – Safety and content filtering.
- **Agents & Tools** – Agent frameworks, Model Context Protocol, coding agents, computer/browser automation, memory management, and testing/evaluation.
- **Research, Training & Fine-tuning** – Security, sandboxing, and model development.
- **Hardware** – Local hardware options.
- **Tutorials** – Guides covering models, prompt/context engineering, inference, agents, and RAG.
- **Communities** – Places to connect and share knowledge.
Anurag Singh replaced his home lab cron scripts with Qwen3.5 9B using an agent harness with shell access. He expected contextual reasoning to be superior to rigid automation. The local model succeeded in identifying ballooned directories or judging if a container restart was needed, but it failed more often, sometimes stalling or silently skipping checks.He concluded that deterministic scripts remain the more dependable choice for routine tasks and pointed to n8n as a sensible middle ground when the friction is writing and maintaining code rather than the logic itself.
- A 9-billion-parameter local model needs several GB of RAM just to load weights, which is painful on a home server already running Docker, DNS, and other services.
- Singh's specific hardware ceiling: roughly 14B parameters on a 16 GB MacBook, maybe 32B on an M5 Pro, beyond which you need a dedicated rig.
- His suggested hybrid: let the local model read an error log and draft a short explanation, then have n8n relay that summary without granting the model permission to restart or modify anything.
The model's failure mode was not wrong commands but an inconsistent process—the same prompt and the same system state, yet different execution paths on successive runs.
- A 9-billion-parameter local model needs several GB of RAM just to load weights, which is painful on a home server already running Docker, DNS, and other services.
- Singh's specific hardware ceiling: roughly 14B parameters on a 16 GB MacBook, maybe 32B on an M5 Pro, beyond which you need a dedicated rig.
- His suggested hybrid: let the local model read an error log and draft a short explanation, then have n8n relay that summary without granting the model permission to restart or modify anything.
The model's failure mode was not wrong commands but an inconsistent process—the same prompt and the same system state, yet different execution paths on successive runs.
Alibaba has open-sourced Qwen-UI-Agent, a GUI agent foundation model that operates across mobile, desktop, web, and deep-search environments on real hardware rather than relying on simulation. It achieves top benchmark results: 82.1% on MobileWorld, 79.5% on OSWorld-Verified, and first on WebArena. It also introduces MobileWorld-Real, a 400+ task benchmark on 100+ phones and 150+ apps, with a 92.2% success rate.
- Supports command-line execution alongside standard GUI operations and batches multiple actions into a single decision step to shorten trajectories.
- Built-in safety layer refuses illegal or high-risk requests outright and pauses at sensitive operations (payments, data deletion, privacy grants) for explicit user confirmation.
- Trained via online reinforcement learning on trajectories exceeding 100 steps, paired with adaptive curriculum learning to progressively tackle longer tasks.
- Supports command-line execution alongside standard GUI operations and batches multiple actions into a single decision step to shorten trajectories.
- Built-in safety layer refuses illegal or high-risk requests outright and pauses at sensitive operations (payments, data deletion, privacy grants) for explicit user confirmation.
- Trained via online reinforcement learning on trajectories exceeding 100 steps, paired with adaptive curriculum learning to progressively tackle longer tasks.
Nous Research has bundled Bot Mode as default in Hermes Agent v0.20.3 for Hermes Desktop, replacing the single-agent session list with a roster of named bots that each have their own chat, memory, skills and pinned model for multi-agent workflows on the desktop.
Key technical details:
* Standalone repo archived; active development continues in-tree at `apps/desktop/src/plugins/hermes-bots/`, first shipped as a one-day public beta plugin by co-founder Teknium
* Bots are stored as isolated profiles under `~/.hermes/profiles//` with own config, memory, skills, credentials and history; managed via existing `profiles.*` gateway RPCs `list, create, describe, configure`
* Avatars generated via the `image.generate` RPC; options include geometric faces in seven shapes/ten colors or uploaded/generated portraits/pixel pets
* Routines are ordinary Hermes cron jobs namespaced ` bot: » `; bot-to-bot messaging uses a persistent Agent Inbox with CLI handoffs e.g. `hermes -p chat -c "Agent Inbox" -q "..."` and `@mention` handoffs
* Per-bot config via New Agent dialog supports cloning a profile, pinning provider/model, custom SOUL.md and skills; duplicates clone config, skills, SOUL.md, memory and appearance
* Bundled version adds Groups for roster sections synced across machines, Group chats for 2-6 bots with up to three serial rounds, and a multi-source roster pulling bots from every connection under Settings → Connections
Key technical details:
* Standalone repo archived; active development continues in-tree at `apps/desktop/src/plugins/hermes-bots/`, first shipped as a one-day public beta plugin by co-founder Teknium
* Bots are stored as isolated profiles under `~/.hermes/profiles//` with own config, memory, skills, credentials and history; managed via existing `profiles.*` gateway RPCs `list, create, describe, configure`
* Avatars generated via the `image.generate` RPC; options include geometric faces in seven shapes/ten colors or uploaded/generated portraits/pixel pets
* Routines are ordinary Hermes cron jobs namespaced ` bot: » `; bot-to-bot messaging uses a persistent Agent Inbox with CLI handoffs e.g. `hermes -p chat -c "Agent Inbox" -q "..."` and `@mention` handoffs
* Per-bot config via New Agent dialog supports cloning a profile, pinning provider/model, custom SOUL.md and skills; duplicates clone config, skills, SOUL.md, memory and appearance
* Bundled version adds Groups for roster sections synced across machines, Group chats for 2-6 bots with up to three serial rounds, and a multi-source roster pulling bots from every connection under Settings → Connections
Michael Larabel writes that Meta Superintelligence Labs announced the release of Muse Glimmer, a 30-billion-parameter open model for always-on local agent workflows with weights released under Apache 2.0. The model is sized to run on a single consumer GPU and targets local coding agents, LLM-as-a-judge evaluation and similar uses, having been trained and evaluated for end-to-end agentic task completion, multi-step reasoning and optimized local deployment. Details are posted on research.meta.ai and the model is available on Hugging Face, with Ollama 0.32.7 already adding support.
-
-
