Once I connected Hermes to Telegram, it became much more useful. I could message it from anywhere, test workflows quickly, and treat it less like a terminal-bound tool and more like an assistant I could actually reach when I needed it.

The setup is not hard, but a few details matter. The main one is this: Hermes splits credentials and behavior into different places. Your secrets go in .env. Your Telegram behavior lives in config.yaml. Put those in the wrong place and you will waste time for no good reason.

Here’s the clean way to set it up.

What You Need Before You Start

Before touching any config files, make sure you already have:

• Hermes installed on your machine
• a Telegram account
• a Telegram bot token, which you will create in a moment

Create a Telegram Bot

Open Telegram and search for @BotFather.

Start a chat and run:

/newbot

BotFather will walk you through the rest. You give the bot a name, then a username, and in return Telegram gives you a bot token that looks something like this:

123456789:ABCdefGhIJKlmNoPQRsTUVwxyZ

Save that token somewhere safe. You will need it shortly, and you should not paste it around carelessly.

Find Your Telegram Chat ID

Next, search for @userinfobot in Telegram and start a conversation with it.

It replies with your numeric Telegram user ID. It will look something like this:

123456789

Save that too.

This is the ID Hermes uses to decide who is allowed to talk to your bot.

Put Credentials in .env

This is the part that is easy to get wrong.

Your Telegram bot token and allowed user list belong in:

~/.hermes/.env

They do not belong in config.yaml.

Open ~/.hermes/.env and add or update these values:

# Telegram bot token from @BotFather
BOT_TOKEN=your_bot_token_here
TELEGRAM_BOT_TOKEN=your_bot_token_here

# Your numeric Telegram user ID from @userinfobot
# For multiple users, separate with commas
TELEGRAM_ALLOWED_USERS=123456789

If you are the only one who should be able to talk to the bot, keep just your own ID there. If multiple people should have access, separate their IDs with commas.

Set Telegram Behavior in config.yaml

Once credentials are in place, configure how Hermes should behave on Telegram.

Open:

~/.hermes/config.yaml

Then add a telegram: section if it does not already exist:

telegram:
  require_mention: true

This setting controls whether Hermes only responds when explicitly mentioned.

With require_mention: true, you need to call the bot directly in the chat, usually by mentioning its username.

With false, Hermes responds to all messages in allowed chats, which is fine in some setups but not always what you want.

For most people, true is the safer default.

Optionally Add a Prefix

If you have multiple bots in the same chat, or just want cleaner control over what triggers Hermes, you can also define a prefix.

Example:

telegram:
  require_mention: true
  prefix: "/hermes"

That means users must type something like:

/hermes summarize this

It is optional, but useful if the bot shares a noisy group chat with other tools. If you want to go broader than Telegram later, this roundup of tools to build your own chatbots is a decent next stop.

Restart the Gateway

After editing .env and config.yaml, restart the Hermes gateway so it reloads the new settings:

hermes gateway restart

If you want to confirm it actually came back up, run:

hermes gateway status

That is usually enough. No drama required.

Test the Bot

Now open Telegram, find your bot by its username, and send it a message.

Something simple is fine:

Hello, are you there?

If everything is configured correctly, Hermes should reply.

And that is the moment it stops feeling like a local experiment and starts feeling properly useful.

What Usually Goes Wrong

If Hermes does not respond, these are the first things I would check.

The Token Is Wrong

Double-check that the bot token in .env is correct.

One bad character is enough to make the whole thing quietly fail.

The Allowed User ID Is Wrong

Make sure TELEGRAM_ALLOWED_USERS contains the correct numeric Telegram user ID.

If the ID is wrong, Hermes may be working perfectly and still ignore you.

The Gateway Was Not Restarted

If you edited the config but did not restart the gateway, Hermes may still be running with the old settings.

The Wrong Bot Token Is Being Loaded

If you manage multiple Telegram bots, make sure Hermes is reading the token you think it is reading.

That one gets people more often than they admit.

Network or Firewall Issues

If outbound connections to Telegram are blocked, the bot will not behave no matter how correct your config is.

A Quick Security Note

Do not share your bot token publicly.

Treat it like a credential, because it is one.

Also, keep the TELEGRAM_ALLOWED_USERS list tight. That list is effectively your access control layer for Telegram chat access.

Final Thought

Once Hermes is connected to Telegram, the whole setup feels different.

It is still your local agent. It is still running on your machine. But now it is reachable from anywhere, which makes it much easier to use in real life instead of only when you happen to be sitting at your desk.

If you set it up cleanly, the whole thing is surprisingly painless.

The post How to Connect Hermes to Telegram appeared first on Hongkiat.

In this article, we’ll look at 10 OpenClaw alternatives, from lightweight options like PicoClaw to more full-featured tools like Moltis, to help you choose the right fit for your next AI agent project.

Let’s start with Nanobot.

Nanobot

Nanobot is a lightweight, open-source AI agent framework developed by the University of Hong Kong (HKUDS). It is designed as a minimal alternative to OpenClaw.

It provides similar capabilities in only a few thousand lines of Python. That makes it easier to deploy, modify, and run on modest hardware. It also supports multiple LLM providers with built-in memory.

Pros

• Lower resource footprint: It starts in less than a second and uses very little RAM. That makes it a practical fit for a cheap VPS or an older laptop.
• Regional messaging support: Besides popular platforms like WhatsApp and Telegram, it supports Asian enterprise platforms like DingTalk and QQ.
• Built-in MCP support: It leans on MCP, so you can plug in MCP-compatible tools like Brave Search or Google Drive without extra plugins or external tooling.

Cons

• No GUI: Unlike OpenClaw, Nanobot is strictly CLI- and chat-based. If you want a point-and-click experience, this is not it.
• Fewer out-of-the-box skills: OpenClaw has ClawHub, a registry of community-made skills. With Nanobot, you’re more likely to write a small script or connect an MCP server yourself.

Nanobot is a strong choice if you want a fast, hackable framework for building personal AI agents.

NullClaw

NullClaw is a high-performance, open-source AI agent runtime built as a tiny single-binary tool. It is designed for efficiency, so it can run on ultra-low-end hardware with near-instant boot times while still supporting 50+ LLM providers, secure sandboxing, and modular integrations.

Pros

• Better performance: It is known for its 678 KB binary size and roughly 1 MB RAM footprint. Compare that with OpenClaw, which is built with Node.js and often needs far more memory. It also boots in under 2 milliseconds.
• Edge and IoT ready: It can run comfortably on a Raspberry Pi Zero or even a router.
• Zero dependencies: It is written in Zig and compiled to a static binary, so it does not require Python, Node.js, or another runtime on the host machine.

Cons

• No GUI: Configuring NullClaw means editing JSON or YAML files and understanding system paths. It lacks the friendlier installer and dashboard experience that OpenClaw offers.
• Developer barrier: If you want to modify the core code, you need to know Zig, which is far less common than JavaScript or Python.

If you’re looking for a lightweight, fast, and privacy-focused AI agent, NullClaw is a compelling option. It works well on a cheap VPS or embedded device where it can handle tasks quietly in the background.

NanoClaw

NanoClaw is a lightweight, open-source personal AI agent designed to run locally on your machine. While OpenClaw aims to be an all-in-one Swiss Army knife, NanoClaw takes a more focused, security-first approach.

Its minimal single-process architecture makes it easier to set up and run on low-powered devices like a Raspberry Pi. It also includes built-in support for WhatsApp, Telegram, Slack, and Gmail.

Pros

• OS-level isolation: NanoClaw runs each agent in its own Docker container or Apple Container on macOS. If an agent is compromised by a malicious site or prompt injection, it stays contained.
• Per-group privacy: Each WhatsApp or Telegram group gets its own isolated container, memory file, and filesystem. That reduces the risk of one chat leaking into another.
• Scheduled tasks: NanoClaw lets you schedule tasks at specific times or intervals, which is useful for reports, update checks, or cleanup jobs.

Cons

• Claude-locked: While OpenClaw supports many models, NanoClaw is closely tied to Anthropic. If you do not want to use Claude, this will be limiting.
• No GUI or dashboard: There is no point-and-click desktop app. Setup and management happen through the terminal and messaging apps.
• Setup complexity: It aims for low configuration, but you still need Docker or another container runtime installed and running.

NanoClaw makes sense if you want a secure and simple AI assistant that can handle private data safely inside isolated containers.

PicoClaw

PicoClaw is an open-source AI assistant designed for very low-cost hardware. It uses minimal resources, starts quickly, and can still handle reminders, web searches, basic automation, and chat-based commands.

That makes it a good choice for personal projects, edge computing, or lightweight AI assistants that do not need powerful machines.

Pros

• Asian platform support: Out of the box, it supports platforms like QQ, DingTalk, and LINE, which are often secondary in Western-focused frameworks.

Cons

• No browser automation: OpenClaw’s biggest strength is its ability to use a computer directly. PicoClaw is a headless agent. It communicates through APIs and messages but cannot control a live browser window yet. A proposal has been added, but the feature is not available at the time of writing.
• No GUI: Everything is configured through a config.json file and used through Telegram or the terminal. If you want a graphical interface, this may be a deal breaker.

If you need a lightweight AI assistant for low-cost hardware with strong Asian platform support, PicoClaw is worth a look.

ZeroClaw

ZeroClaw is a lightweight, Rust-based AI agent runtime built for fast local execution. It needs under 5 MB of RAM and ships as a binary of roughly 3.4 MB.

It connects to providers like OpenAI, Anthropic, and local models. It also handles memory, tools, and workflows behind the scenes while storing data locally in SQLite, which helps keep everything private and under your control.

Pros

• Lightweight: It can run on a single-core CPU while using very little RAM.
• High concurrency: ZeroClaw uses Rust’s async model to handle many simultaneous tasks with lower CPU overhead than heavier runtimes.
• Custom provider support: It supports custom providers, so you are not limited to only OpenAI or Anthropic.

Cons

• The Rust learning curve: Unless you already know Rust, customizing the core or writing advanced native plugins will be harder than doing the same in JavaScript or Python.
• Broad provider support can add complexity: It supports 20+ providers including Ollama, DeepSeek, Moonshot, and others. That flexibility is useful, but it can also make configuration more involved.

Like NullClaw and PicoClaw, ZeroClaw is a solid fit if you want an AI agent that is fast, reliable, and able to handle heavier workloads without using much memory.

IronClaw

IronClaw is a secure, open-source AI assistant you can run on your own machine. It focuses on privacy and safety by keeping workloads local and protecting sensitive information like credentials.

It isolates AI tasks in secure environments, monitors activity, and gives you tighter control over tool access. You can interact with it through APIs or messaging apps like Telegram and Slack, which makes it a flexible and security-focused alternative to OpenClaw.

Pros

• WASM sandboxing: Unlike OpenClaw, which often runs tools on the host or inside general containers, IronClaw executes untrusted tools in isolated WebAssembly sandboxes.
• Credential protection: It uses a credential injection model where the AI model itself never sees your API keys. Secrets are injected only at execution time.
• Better performance: It offers a small memory footprint and quick startup times.

Cons

• NEAR ecosystem dependency: To use many of its features, you currently need a NEAR AI account. That adds third-party authentication to the mix.
• WASM plugin limits: The sandboxed model improves safety, but it can also limit compatibility with tools that expect full native access.

IronClaw is best suited to security-sensitive work, especially when the agent may handle credentials, financial data, or internal systems.

OxiBot

OxiBot is a lightweight AI assistant built in Rust that you can run on your own machine. It is designed to be fast, secure, and simple while using fewer system resources than larger AI tools.

It is effectively a port of Nanobot with a similar configuration model and feature set, but built in Rust instead of Python. It ships as a single static binary that is easy to deploy and run.

Pros

• Rust-based: Built with Rust, it offers better performance and memory efficiency than many Python-based alternatives.
• Nanobot clone: If you are already familiar with Nanobot, OxiBot will feel immediately familiar.
• Single static binary: It comes as one static binary that is easy to deploy and run.

Cons

• Development friction: Rust is powerful, but it is harder to modify and extend than the JavaScript or Python used by many other tools in this category.
• Headless by nature: It is not built for browser automation in the same way OpenClaw is. It focuses on text, tasks, and command execution rather than GUI control.

OxiBot is a practical choice if you want a fast local assistant with low overhead, especially if you plan to pair it with a local model like Ollama.

MaxClaw

MaxClaw is a local AI assistant built with Go and designed to run on your own machine with relatively low memory usage. It works as a single efficient program that handles tasks, tools, and workflows without needing cloud services.

Pros

• Go-based: Built with Go, it offers strong performance and memory efficiency compared with many JavaScript- or Python-based alternatives.
• GUI: It includes a simple interface for chatting, managing files, and running commands in one place.

Cons

• Limited providers: It seems to support only OpenAI and Anthropic. That may be restrictive if you prefer providers like Ollama or DeepSeek.
• No Windows support: Both the GUI and CLI are available only on Linux and macOS.

MaxClaw is a good fit if you want a fast, lightweight local AI assistant with a GUI, though it is a weaker choice for Windows users.

CoPaw

CoPaw is an open-source AI agent platform that lets you run and manage agents locally or in the cloud. It is easy to set up and includes a simple web interface for chatting, configuring agents, and tracking usage.

It supports integrations with apps like Discord and iMessage, works with local AI models for better privacy, and includes support for skills that extend its capabilities. You can get started with a one-line install script or Docker.

Pros

• Multi-channel support: CoPaw has built-in support for iMessage, Discord, Telegram, DingTalk, Feishu, and QQ.
• Built-in MCP and skills: It includes MCP and skills out of the box, making it easier to add tools and capabilities.
• Web interface: It provides a simple interface for chatting with agents, configuring them, installing MCP, and adding providers.

Cons

• Resource overhead: It needs more system resources than lightweight alternatives like PicoClaw or MaxClaw.
• Python dependencies: It relies on Python, which can offer flexibility but also adds environment and compatibility overhead.

CoPaw is a good option if you want a local AI assistant that spans multiple platforms and comes with a ready-made web interface.

Moltis

Moltis is a self-hosted AI assistant built in Rust that runs as a single binary on your own machine. It works as a local hub that can connect to different AI providers while keeping everything private.

It includes long-term memory, voice support, and secure tool execution, and can be accessed through a web interface or apps like Telegram and Discord.

Pros

• Native desktop app: Moltis provides a dedicated desktop experience that feels more like a workstation than a simple chatbot.
• Voice support: It includes built-in voice support for hands-free interaction.
• GraphQL API: It offers a GraphQL API for developers who want programmatic access.

Cons

• GUI reliance: Moltis is heavily GUI-driven. If you want a headless agent that runs quietly on a server, OpenClaw or Nanobot are better fits.

Moltis is best suited to people who prefer a polished desktop interface and workspace-style setup while still running everything locally.

Wrapping Up

Since we last looked at OpenClaw, an entire ecosystem of alternatives has emerged. Many aim to cut the requirements from something that feels heavy to something that can run on a much smaller machine.

Here’s a quick breakdown of the key players we’ve covered to make the choices easier to compare:

The post 10 OpenClaw Alternatives Worth Trying appeared first on Hongkiat.

You explain a workflow, mention a preference, or spend half an hour giving useful context. The chat goes well. Then the next session starts and you are back to repeating yourself.

That is the problem OpenClaw's Dreaming feature is trying to solve. It is still marked as experimental at the time of writing, but the idea is already useful.

Instead of treating memory like a junk drawer, Dreaming periodically reviews what happened, keeps what matters, and leaves the rest behind. The goal is simple: help your AI remember the right things.

Why "Dreaming"?

Because sleep is when the brain sorts things out.

We do not remember every tiny detail from the day. We keep the useful parts, drop the noise, and sometimes connect ideas in a way that only makes sense later.

OpenClaw is borrowing that idea.

When Dreaming runs, it reviews recent conversations, looks for what keeps coming up, and promotes only the stronger signals into longer-term memory. It also writes a plain-English summary of what it noticed.

That part matters.

A lot of AI memory features feel like black boxes. Dreaming is easier to trust because you can actually inspect what it decided was worth keeping.

How Dreaming Works

At a high level, Dreaming runs on a schedule. The default is nightly at 3 AM, though that can be customized.

The process is split into three phases.

1. Light Phase

This is the cleanup pass.

Dreaming goes through recent conversations, removes duplicates, and organizes the noise before anything gets promoted.

2. REM Phase

This is the reflection pass.

The system looks for patterns, recurring topics, and things that keep coming up. If you keep talking about the same project or problem, that starts to matter.

3. Deep Phase

This is where promotion decisions happen.

The system scores what it found and only promotes the strongest memories into long-term storage, such as MEMORY.md.

That part matters because Dreaming is disposable by default. It is not trying to save everything forever. It is trying to keep what will still be useful later.

The Dream Diary Is the Best Part

After each cycle, OpenClaw writes a summary to DREAMS.md.

It is basically a short diary entry in plain English showing what the system noticed. Something like:

"You've been talking a lot about network routing configurations lately. This looks like an ongoing project."

That transparency makes the feature easier to trust.

Instead of asking you to believe a black box, OpenClaw shows its work. You can read the diary, inspect what it thinks is important, and decide whether the memory behavior feels sensible.

There is also a Dreams UI you can open with Ctrl + I, which gives you a nicer way to browse that information.

How to Turn Dreaming On

Dreaming is disabled by default, so you need to enable it explicitly.

You can do that in your OpenClaw config like this:

{
  "plugins": {
    "entries": {
      "memory-core": {
        "config": {
          "dreaming": {
            "enabled": true
          }
        }
      }
    }
  }
}

You can also customize the schedule if you do not want it running only once a night. For example, you might prefer a shorter interval like every six hours, depending on how heavily you use your agent.

If you would rather manage it from chat, OpenClaw also supports slash commands:

• /dreaming on
• /dreaming off
• /dreaming status
• /dreaming help

And if you want more control, there are CLI tools for previewing what would be promoted and understanding why something made the cut.

That is useful if you are the kind of person who likes seeing the scoring logic before trusting automation.

Why This Matters

Without some kind of memory consolidation, AI assistants tend to become either forgetful or cluttered.

Forgetful is obvious: the assistant loses important context and becomes less useful over time.

Cluttered is the quieter problem. If a system saves too much, long-term memory fills up with noise. Old one-off details start sitting beside real preferences and active projects. The result is not intelligence. It is hoarding.

Dreaming aims for the middle ground: keep less, but keep the right things. If it works well, your AI becomes more useful over time because it retains context more cleanly.

Why This Lands at the Right Time

This feature also lands at a good time.

A lot of developers have been complaining lately that AI coding tools feel less dependable than they used to. When that happens, memory matters more. If an assistant already makes mistakes, it feels even worse when it also forgets your setup, preferences, and ongoing work – especially in more hands-on setups like local AI assistance in VS Code.

Dreaming does not fix weak reasoning. But it can reduce one layer of friction by helping the agent stay grounded in the context that actually matters.

The post OpenClaw's Dreaming Feature Helps Your AI Remember Better appeared first on Hongkiat.

It works. But it doesn’t always feel fast.

You send a message, wait a couple of seconds, then start wondering if something is broken. Sometimes the reply comes back quickly. Sometimes it takes 10 to 15 seconds. And sometimes it feels like the bot wandered off to make coffee before answering.

The short version: some delay is normal.

A Telegram bot backed by a full AI agent has more work to do than a typical chatbot. It has to receive the message, pass it through the gateway, load conversation history, decide whether tools are needed, generate the response, and send everything back through Telegram.

That stack takes time.

Still, not every delay is normal. When simple replies keep dragging, or the latency feels random, there’s usually something in the setup worth fixing.

Is OpenClaw Telegram Latency Normal?

Yes, to a point.

For most setups, the rough baseline looks like this:

• Simple messages: around 2 to 5 seconds
• More complex requests: around 8 to 15 seconds
• Tool-heavy or long-context tasks: sometimes longer

That’s typical for LLM-powered bots.

If you’re using a larger model, sending reasoning-heavy prompts, or carrying a long chat history, the extra delay makes sense. These systems aren’t just matching rules and returning canned replies. They’re processing context, generating tokens, and sometimes calling tools along the way.

Where it stops feeling normal is when:

• basic replies regularly take more than 15 seconds
• the bot stays on “typing…” for too long
• responses sometimes jump to 30 to 60 seconds without a clear reason
• the bot feels like it needs a manual wake-up

That’s usually a sign that the slowdown is fixable.

Why OpenClaw Telegram Replies Are Slow?

The total response time usually comes from a few smaller delays stacked together.

Telegram Polling Adds a Bit of Drag

If you’re using long polling, OpenClaw has to keep checking Telegram for new messages.

That works, but it adds a bit of lag. Polling connections can also stall, which makes the bot feel sleepy until something nudges it again.

Webhooks are usually faster because Telegram pushes updates to your bot directly instead of waiting to be polled.

This usually isn’t the main problem.

But it does add drag.

Model Processing Is Often the Biggest Cost

This is usually where the real time goes.

The model needs to:

• read the conversation history
• understand the prompt
• decide what to do
• generate the response token by token

A short question with almost no history is cheap.

A long conversation, a heavyweight model, and a prompt that triggers tool use? Much less cheap.

That’s why the same bot can feel fast one moment and noticeably slower the next.

Partial Streaming Can Make the Bot Feel Slower

This one catches a lot of people.

If partial streaming is enabled, the bot may send tiny chunks as they arrive. That sounds faster on paper. In practice, it can feel slower because Telegram keeps showing typing indicators while the answer trickles in.

You’re technically seeing output earlier, but the overall experience feels more drawn out.

Not ideal.

IPv6 Issues Can Cause Huge Delays

This is one of the most common causes of random slowdowns.

Node.js tends to prefer IPv6 first. If your VPS or hosting provider has flaky IPv6 routing to Telegram or your model provider, requests can hang before they fall back to IPv4.

The result is nasty.

Everything looks fine, but every request quietly pays a timeout penalty.

If your bot sometimes replies in a few seconds and other times takes nearly a minute, this is one of the first things I’d check.

Server and Hosting Still Matter

Sometimes the answer is boring.

Low CPU, low RAM, poor routing, cold starts, or a server that’s simply far from your region can all add latency.

Not glamorous. Still real.

Long Chat History Slows Things Down

Long conversations are expensive.

Persistent context is useful right up until it starts getting in the way. If every new message forces the model to chew through a giant backlog, even small replies start getting slower.

Convenient? Yes.

Free? Not even close.

What to Fix First

If your OpenClaw Telegram bot feels slower than it should, try these fixes in order.

1. Check Your Streaming Mode

If your Telegram config is using partial streaming, try disabling it or switching to full-response mode.

This is often the quickest win: replies feel snappier end to end.

In OpenClaw, draft streaming is controlled by channels.telegram.streamMode (off, partial, or block). Default is partial. Set it to off so Telegram gets one complete reply instead of draft-bubble updates (full-response style). Optional: block still uses drafts but refreshes in larger chunks than partial.

Edit your gateway config (for example ~/.openclaw/openclaw.json), then restart the gateway:

{
  "channels": {
    "telegram": {
      "streamMode": "off"
    }
  }
}

If you later want partial draft streaming again, set "streamMode": "partial" (or remove the key so the default applies).

2. Force IPv4 First

If your setup has flaky IPv6 routing, this can make a dramatic difference.

For systemd-based setups, the common fix looks like this:

Environment="NODE_OPTIONS=--dns-result-order=ipv4first"

Then reload and restart the gateway.

If your Telegram channel config supports dnsResultOrder, you can set the equivalent there too.

This isn’t one of those tiny tweaks that may or may not matter.

When IPv6 is the problem, this fix tends to hit immediately.

3. Reduce Context Bloat

If the bot gets slower over time, clean up the session.

A few simple habits help:

• use /new to start fresh
• use /compact to shorten long histories
• lower context limits in config if needed

Not every chat needs to carry its full life story.

4. Try a Faster Model

For everyday Telegram use, smaller and faster models often feel better.

If you’re using a large model for casual back-and-forth, you’re probably trading responsiveness for depth you don’t need on every message.

Use the bigger models when the task deserves it. Use the faster ones when you just want the bot to respond like a normal creature.

Good options to try: GPT-4o mini, Claude Haiku, or Gemini Flash on the cloud side; a compact Llama or Qwen locally. They’re built for speed, not benchmarks — which is the right trade-off for Telegram.

5. Use Webhooks If Your Setup Supports Them

Polling is simpler.

Webhooks are usually faster.

If low latency matters to you, it’s worth testing a webhook-based setup to see whether it feels more responsive in real usage.

6. Check the Boring Stuff Too

This part isn’t exciting, but it matters:

• make sure your server has enough CPU and RAM
• host closer to your region if possible
• keep OpenClaw updated
• check logs for timeouts, fallback behavior, or repeated failures

When a system feels slow, the logs are usually less confused than the human reading them.

A Simple Rule of Thumb

If basic replies take a few seconds, that’s fine.

If heavier prompts take longer, also fine.

If trivial messages are consistently slow, or the latency feels random and exaggerated, start with these two checks first:

1. streaming mode
2. IPv6 vs IPv4 behavior

Those two cause a surprising amount of pain.

Final Thoughts

Some latency is part of the deal when you run a capable AI agent through Telegram.

That’s normal.

But long, frustrating delays usually aren’t something you have to accept. Most of the time, the cause is less dramatic than people think. It’s usually something ordinary and fixable:

• partial streaming that feels worse than it helps
• bloated context
• flaky IPv6 routing
• a heavyweight model handling lightweight tasks

Which is good news.

Because boring problems are usually easier to fix than mysterious ones.

And once you fix them, the bot starts feeling a lot less like a side project and a lot more like something you’d actually want to use every day.

The post OpenClaw Telegram Bot Slow on Telegram? What’s Normal and What to Fix appeared first on Hongkiat.

I use this to ping my OpenClaw bot hands-free while driving. It just works.

Bot Peer ID First

Before setting things up, you need your bot’s Peer ID. It’s buried in your bot’s API token.

Open the chat with your bot in Telegram. If you created the bot via @BotFather, the confirmation message includes the API token, something like 851234567:AA.... The Peer ID is the number before the colon. In that example, 851234567.

If you can no longer find that message, open @BotFather, select your bot, tap API Token, and Telegram will show the token again.

Write it down. You’ll need it in a second.

Create the Contact

Open the Contacts app on your iPhone. Tap the + button to add a new contact.

Pick a short name, something Siri can recognise easily and unambiguously. I went with “Claw”, but “OpenClaw” or “MyBot” works just as well. Avoid names that sound like other contacts.

Scroll down, tap add url, change the label to Telegram (this part matters, so don’t skip it), then paste:

https://t.me/@oid<PEER_ID>

Replace <PEER_ID> with your actual number. So if your Peer ID is 851234567, the full URL becomes:

https://t.me/@oid851234567

Save the contact.

One Prerequisite

Make sure you’re using the official Telegram app on iPhone and that it’s reasonably up to date. This trick relies on Telegram’s iOS contact integration, so if the Telegram URL label does not show up in Contacts, update the app first.

The bot won’t respond unless you’ve already sent it at least one message from your account. If you’ve never chatted with it before, open the bot in Telegram, hit Start or send any message, then come back.

Using It

• Say “Hey Siri, message Claw on Telegram”, using whatever name you gave the contact.
• Siri opens the Telegram chat with your bot and is ready for your next voice command.
• On CarPlay, the same contact appears in your app list and responds to your car’s voice assistant.

It’s the same mechanism, just carried over to a driving context.

What Actually Works

• Any Telegram bot you have an existing chat with, not just OpenClaw bots.
• The contact name needs to be short and distinct. Naming a contact “Test” or “Bot” will confuse Siri.
• If you rename the contact later, update the Siri phrase accordingly.

The post Use Siri to Message Your Telegram Bot (Yes, Even on CarPlay) appeared first on Hongkiat.

On paper, it checks a lot of boxes: long context windows, multimodal input, strong reasoning, broad language support, and an Apache 2.0 license that makes it easier to use in real projects without weird restrictions hanging over your head.

But most people asking about Gemma 4 are not starting with the license.

They are asking a simpler question:

Can I actually run this on my own computer?

The short answer is yes.

And more interestingly, you probably can without needing some absurd server rack in the corner of your room.

Gemma 4 comes in a few sizes, from smaller models that should be comfortable on laptops and edge devices, all the way up to much larger variants that make more sense on high-end GPUs or machines with plenty of unified memory. So whether you are just curious, privacy-minded, or trying to run models locally for coding, testing, or agent workflows, there is likely a version that fits.

If you are new to this whole setup, these apps for running AI locally are a useful starting point before you go deeper into model sizes and hardware tradeoffs.

In this post, I will walk through what Gemma 4 is, which model sizes are available, what kind of hardware you will need, and the easiest ways to run it locally.

What Is Gemma 4?

Gemma is Google DeepMind’s family of open-weight models built from the same research direction behind Gemini. Earlier releases already had a decent reputation among people who like running models locally, mainly because they delivered more than you would expect for their size.

Gemma 4 pushes that further.

At launch, the lineup includes four variants:

• Gemma 4 E2B: a small model aimed at lightweight devices
• Gemma 4 E4B: a more capable small model that should be the sweet spot for many people
• Gemma 4 26B A4B: a Mixture-of-Experts model with only a smaller portion active per token
• Gemma 4 31B: the largest dense model in the family

Google positions the family as multimodal, with native vision and audio support, along with long context windows that scale up to 256K on the larger models. It also supports over 140 languages, which makes it more interesting for global use than models that mainly feel tuned for English-first workflows.

The practical takeaway is this: Gemma 4 is not just another open model release for benchmark watchers. It is meant to be usable.

That matters.

Because the moment a model becomes easy to run locally, it stops being just a research headline and starts becoming part of real workflows.

Can You Run Gemma 4 Locally?

Yes. That is one of the most appealing things about this release.

The smaller Gemma 4 variants are meant for local and edge use, so you do not need elite hardware just to try them. If you have run other local models through Ollama, LM Studio, llama.cpp, or Transformers, the setup here will feel familiar.

• Ollama if you want the fastest way from zero to running model
• LM Studio if you prefer clicking over terminals
• Hugging Face + Transformers, llama.cpp, or vLLM if you want more control
• Kaggle if you want access through Google’s own ecosystem

Once downloaded, local use also means the obvious benefits kick in: better privacy, offline access, and less dependency on API pricing or rate limits.

That alone will be enough to pull in a lot of developers.

Can Your Computer Handle It?

This is where things get real.

A model may be open, but that does not automatically mean it will run well on your computer. The main limiting factor is memory, especially if you want decent speed and longer context windows.

Here are the approximate base memory requirements for Gemma 4 weights:

That is just the model weights. Real usage needs extra headroom for context, KV cache, and runtime overhead, so it is smarter to treat those numbers as the floor, not the target.

Here is the practical version.

Gemma 4 E2B

This is the lightweight option. In 4-bit form, it should be workable on modest hardware and even CPU-heavy setups. If you just want to test prompts, tinker offline, or run something locally without stressing your computer, this is the easiest entry point.

Gemma 4 E4B

This will probably be the sweet spot for most people. It is small enough to be practical, but large enough to feel more useful for everyday local work. If you are on an M-series Mac or a midrange NVIDIA GPU, this is likely the version to try first.

Gemma 4 26B A4B

This is where things start getting more serious. Because it is a Mixture-of-Experts model, it may be more efficient than the raw parameter count suggests, but it still wants real hardware. A high-end GPU or a well-specced Mac Studio makes much more sense here.

Gemma 4 31B

This is the big one. If you want the best quality in the family, this is probably where you look. But if you are hoping to run it comfortably, you will want a strong GPU and enough VRAM to avoid a miserable experience.

If you are unsure which version to try, start with 4-bit quantization. It usually gives the best balance between quality, speed, and not making your hardware regret your decisions.

If storage is part of the problem, this guide on running Ollama models from an external drive is worth bookmarking.

How to Run Gemma 4 Locally

The easiest option for most people is still Ollama.

Run Gemma 4 with Ollama

First, install Ollama from ollama.com/download.

Then run:

ollama run gemma4

That pulls the default E4B variant, which is roughly a 9 to 10 GB download.

If you want a specific model size, use one of these instead:

ollama run gemma4:e2b
ollama run gemma4:26b-a4b
ollama run gemma4:26b
ollama run gemma4:31b

Once it starts, you can chat with it directly in the terminal, much like you would with any other local model in Ollama. If you want to go further, this walkthrough on vision-enabled models in Ollama is a good companion once you are comfortable with the basics.

If you are building apps or tools around it, Ollama also exposes an OpenAI-compatible API at:

http://localhost:11434

That makes it easy to plug Gemma 4 into existing local workflows without rebuilding everything from scratch.

Prefer a GUI? Use LM Studio

If you do not want to touch the terminal, LM Studio is the friendlier option.

1. Download LM Studio from lmstudio.ai
2. Search for Gemma 4
3. Pick the quantized version you want
4. Download it and start chatting

If you want a broader look at the tool itself, this post on running LLMs locally with LM Studio covers the setup in more detail.

For Developers

If you want more control, Gemma 4 models are also available through Hugging Face.

• google/gemma-4-E2B-it
• google/gemma-4-E4B-it
• google/gemma-4-26B-A4B-it
• google/gemma-4-31B-it

From there, you can run them using:

• Transformers
• llama.cpp
• GGUF builds
• vLLM
• Unsloth

That route makes more sense if you care about custom serving, benchmarking, quantization experiments, or fitting the model into your own stack.

So, Should You Try It?

If you are curious about local AI, yes.

Not because every model release deserves a standing ovation, but because Gemma 4 seems to hit a useful middle ground: open, capable, and available in sizes that make local experimentation realistic.

That matters more than flashy launch claims.

A model family becomes interesting when normal people can actually run it. Gemma 4 looks like one of those releases.

And if you have got a halfway decent laptop or desktop, there is a good chance you can start today.

The post Gemma 4 Just Dropped. Can Your Computer Handle It? appeared first on Hongkiat.

Starting at 12pm PT on April 4, 2026, Anthropic began enforcing a policy change. Third-party “harnesses” like OpenClaw no longer qualify for subscription usage limits. Heavy or automated workloads now trigger separate pay-as-you-go “extra usage” billing at full API rates. For agentic tasks that consume millions of tokens, this means bills that can run into hundreds or thousands of dollars on what used to be a $20 to $200/month subscription.

This wasn’t sudden. Back in January 2026, Anthropic quietly blocked some of the technical paths that made this workaround possible. February brought a formal terms update explicitly stating that OAuth tokens from consumer subscriptions are only for official Anthropic interfaces (Claude.ai, Claude Code, and so on). Their official Agent SDK overview now says third-party developers are not allowed to offer claude.ai login or subscription rate limits for their own products unless Anthropic approved it beforehand. April 4 is when the enforcement teeth came in.

OpenClaw (also known historically as Clawdbot or Moltbot) is a popular open-source AI agent framework that enables persistent, autonomous agents. For months, a significant chunk of its user base had been routing their subscription OAuth tokens through OpenClaw to run sophisticated workflows far beyond typical chat usage. Effectively, a consumer plan was being used as a subsidized backend for agent swarms.

Can You Still Use Claude with OpenClaw?

Yes, but your costs will be higher for anything beyond light use.

Third-party harness usage now pulls from “extra usage” billing instead of your included subscription limits. Some community workarounds are being tested, routing through the local Claude CLI, but these may still incur extra charges and carry ToS risks. A one-time credit equivalent to one month of subscription is being provided as a transition buffer for affected users.

The official line is now in Anthropic’s docs, not just community screenshots and email quotes. OAuth from Free, Pro, Max, or Team accounts should not be used in third-party products or services.

What This Means in Practice

Cost. Workloads that previously ran efficiently on a $20 to $200/month subscription are now generating substantial extra usage bills. Some users were reportedly burning token volumes equivalent to thousands of dollars monthly, at standard API pricing.

Infrastructure. Anthropic cited capacity strain from high-volume agents overloading consumer-tier systems designed for individual use.

Where heavy users go from here. Subscriptions remain positioned for human-centric, official interfaces. Commercial or agentic use is directed toward proper API keys or Anthropic’s own tools like Claude Code. OpenClaw users are exploring model switches to OpenAI, Minimax, Kimi, or local options.

The subscription hack for running fleets of agents at discounted rates is over.

The Public Reaction

The announcement sparked backlash and debate across Reddit, Hacker News, and X.

On Reddit’s r/ClaudeAI, “All the OpenClaw bros are having a meltdown after the Anthropic subscription lock-down” captured the vibe. Comments described OpenClaw agents as wasteful, token-burning, and a “clobbered together mess.” Community consensus leaned toward Anthropic being right to crack down. One top comment: “Anthropic banned subscription OAuth tokens from all third-party tools, forcing users to either stick with Claude Code only or pay 5 to 10 times more via API keys.”

On Hacker News, reactions were more mixed. In “Tell HN: Anthropic no longer allowing Claude Code subscriptions to use OpenClaw”, one commenter noted: “Using the chatbot subscription as an API was a weird loophole. I don’t feel betrayed.” Another pointed to misaligned incentives: “The organization selling the per-token model doesn’t have the incentive, at scale, to have you reduce token consumption.” A sharper take: “OpenClaw literally brought them customers at the door and now they get them off their platform, with a strong feeling of dislike or hatred towards Anthropic.”

On X, reactions ranged from angry to analytical. Robert Scoble called it a fumble, while another take was simply: Anthropic wasn’t trying to kill OpenClaw.

My Take

Anthropic’s rationale is straightforward. Consumer subscriptions were never designed to subsidize unlimited autonomous agent swarms, and the terms of service were always there. Enforcement just came faster than some expected.

Whether this strengthens their premium positioning or drives users toward competitors will play out over the coming months. For now, if you rely on OpenClaw with Claude, review your authentication setup, monitor for extra usage charges, and have a backup model lined up.

The era of cheap subscription fuel for third-party automation is over. Adjust accordingly.

The post Anthropic Just Closed the OpenClaw Subscription Loophole appeared first on Hongkiat.

Not because the main posts are worse.

Because the replies are often a mess.

You open a post that looks interesting, scroll down, and get hit with the usual mix: spam, ragebait, low-effort jokes, off-topic noise, and increasingly, AI-generated filler that somehow says a lot while contributing absolutely nothing.

So X adding a thumbs-down button doesn’t feel random.

It feels overdue.

The new feature is simple: X has added a thumbs-down button, but only for replies and comments under a post, not for the main post itself. That detail matters. This isn’t Reddit-style downvoting across the whole platform. It’s a quieter feedback tool aimed at cleaning up the part of X that usually needs the most help.

From what we’ve seen so far, the rollout started around March 18, 2026. That’s backed up by Grok’s announcement on X, which says the feature had “just rolled out today” after a user request and Nikita Bier’s “give me 60 seconds” reply. Bier is X’s Head of Product, so this wasn’t just a random viral response. It was a pretty public glimpse into how quickly product experiments can move on the platform.

Fast product iteration is great.

Whether the feature actually improves the platform is the more interesting question.

Why X Added the Thumbs Down Button

The main timeline on X still runs on the usual signals: likes, reposts, replies, and bookmarks. There’s no visible downvote count on the original post, which is probably the right call.

The real problem has never been people liking posts too much.

It’s the reply section.

That’s where threads get clogged with low-quality content, bot replies, AI slop, promotional junk, people who clearly arrived just to make the experience worse for everyone else, and the endless pile of replies asking @grok questions that were already answered in the post they’re replying to.

The thumbs-down button looks like X’s attempt to deal with that without turning every conversation into a public dislike contest.

And I get the logic.

A private negative signal is a lot easier to work with than a public one. People can flag a reply as bad, irrelevant, misleading, or spammy without creating another performative metric for everyone to chase.

In theory, that gives X a cleaner ranking signal. Better replies rise. Worse ones sink. The thread becomes more readable without adding a giant public scoreboard of disapproval.

That’s the pitch, anyway.

Why Limiting It to Replies Makes Sense

If X had added public downvotes to main posts, the whole thing would have turned into a mess almost instantly.

You’d get brigading.

You’d get coordinated dislike attacks.

You’d get people treating downvotes as identity warfare instead of feedback.

By limiting the feature to replies, X keeps the main post focused on distribution and engagement while using the reply layer as a quality-control zone.

That’s a much smarter place to experiment.

It also matches how people already use X. Most users aren’t asking for a public thumbs-down button on every post they disagree with. What they actually want is a way to bury the reply that adds nothing, derails the thread, or reads like it was assembled by a low-budget reply bot trained on engagement bait.

Private feedback is a cleaner mechanism for that.

How the Thumbs Down Button Works

If the feature has rolled out to your account, you’ll see a thumbs-down icon on individual replies.

It usually appears between the like button and the bookmark icon.

Tap it, and you’ll get a reply feedback prompt asking what’s wrong with the reply. The wording is along the lines of:

Tell us what is wrong with this reply. Your feedback is private.

That last part is important.

The dislike count isn’t public. The author doesn’t get a direct notification saying their reply was thumbs-downed. This isn’t meant to shame people in public. It’s meant to feed ranking signals back into the system.

At least for now, the feature also appears to be rolling out gradually, with verified users and Premium subscribers getting it first. That makes sense if X wants to reduce obvious bot abuse while testing the signal quality.

As of writing, the button appears to be showing up mainly on mobile, not the desktop web version of X. That could change quickly, but right now the rollout looks uneven across both accounts and platforms.

Server-side rollout means some eligible users won’t see it immediately.

So if you don’t have it yet, that doesn’t necessarily mean you’re missing something.

What Happens When You Tap It

This is where the feature becomes more interesting than a generic dislike button.

You’re not just saying, “I don’t like this reply.”

You’re telling X why.

And that matters because the platform can use those signals differently depending on the category.

Here are the main feedback options users are seeing:

1. Not Interested in This Post

This is for replies that feel irrelevant, low-value, or just not worth seeing.

Not abusive. Not dangerous. Just bad.

That kind of signal is useful because a lot of the worst replies on X aren’t technically violations. They’re just noise.

2. Incorrect or Misleading

This option is for replies that contain wrong information, misleading claims, or content that may deserve closer scrutiny.

Some users also report that this path can connect with Community Notes workflows, which makes sense. If enough people flag the same kind of misinformation, X has a reason to look harder at it.

3. AI-Generated

This might end up being the most used option of the bunch.

If you’ve spent any time in large threads lately, you’ve probably seen the pattern: polished-looking replies that say nothing, fake agreement replies, generic summaries, weirdly enthusiastic bots, and a flood of synthetic engagement that makes the whole thread feel hollow.

Giving people a direct way to flag that is probably one of the more practical things X has done in a while.

4. Spam

This one’s straightforward.

Promotional junk, repetitive replies, scammy messages, phishing attempts, and all the usual garbage that shows up whenever a platform still has enough reach to be worth exploiting.

5. Report Post

This is the escalation path.

If the reply crosses into harassment, hate speech, impersonation, or clear rule violations, this option hands the issue off to X’s formal reporting flow instead of just using it as a ranking signal.

That’s a useful distinction.

Not every bad reply should be treated the same.

Some deserve demotion. Others deserve review.

What This Could Improve

If X gets the ranking right, this feature could make reply sections a lot more readable.

That’s not a small thing.

One of the reasons long threads feel worse now isn’t that the original posts are always bad. It’s that the replies often bury the interesting conversation under layers of low-effort sludge.

A private thumbs-down button gives X a way to sort for signal instead of just volume.

That could lead to a few obvious improvements:

• fewer spammy and low-value replies near the top
• less visibility for AI-generated filler
• better discussion quality in high-traffic threads
• less incentive for reply farming and ragebait tactics

And because dislike counts stay private, the whole system should be less dramatic than a visible downvote counter.

In theory, anyway.

The real risk is whether people use it thoughtfully, and whether X can separate useful feedback from coordinated misuse.

That’s always the hard part.

Also worth noting: feature rollouts tend to attract scams.

If you get an email or message claiming you need to verify your account to unlock the new dislike feature, treat that with suspicion. X feature launches are noisy enough on their own. Scammers love that kind of confusion.

My Take

This feels like one of those small product changes that could have a surprisingly large effect.

Not because the button itself is revolutionary.

It isn’t.

But because reply quality has become one of the biggest reasons X feels worse to use than it used to.

If this helps bury spam, demote AI slop, and reduce the visibility of junk replies without turning every thread into a public downvote circus, that’s a good trade.

The strange part?

What users probably wanted wasn’t more public feedback.

They wanted better conversations.

And this might actually be a more sensible way to get there.

The post X Just Added a Thumbs Down Button for Replies appeared first on Hongkiat.

People usually use Grok in a few places: on the X site at x.com/grok, on grok.com, or in the X app on their phone.

Does Grok have an app for Mac?

Right now there’s no standalone Grok app for Mac, and no X app for Mac either. X and Grok exist as apps on iPhone and iPad, but not on macOS.

You can still use Grok on your Mac with a few workarounds. Here’s how.

Why use Grok on your Mac?

Having Grok on your Mac means you don’t have to open x.com, log in, and hunt for Grok every time. You can jump straight into a chat instead of going through the X site each time.

How to install Grok on Mac

1. Use Raycast

Raycast is a popular Mac launcher and productivity tool. You bring it up with a shortcut (usually Option + Space), then type to search apps, run commands, and more.

Raycast AI is built in. You can pick from a bunch of AI models in one place, including Grok. You can switch between providers and models inside Raycast AI.

Free users get a 50-message trial and can try any of the Pro models, including Grok. You can test it before paying.

The Grok models currently available in Raycast include:

• Grok-4 (and variants such as Grok-4 Fast and Grok-4 Reasoning)
• Grok-3 Beta and Grok-3 Mini Beta
• Grok-4.1 Fast

2. Use Fello AI

Fello.ai is another option in the same vein as Raycast. It’s a desktop app for Mac (and iOS/iPadOS) where you can talk to several AI models in one place: ChatGPT, Claude, Gemini, DeepSeek, and Grok.

You switch models from a menu. You can pin chats, search history, and upload files. One app instead of juggling a bunch of AI sites.

Fello AI has a free tier. You get a limited number of questions per hour (the limit varies) that include Grok. The count resets every hour. On the free tier you don’t get PDF or image analysis; that’s on paid plans.

If you need more questions or file support, you’ll need a subscription. Paid plans are weekly ($3.99), monthly ($9.99), or yearly ($79.99). Check the Mac App Store or felloai.com for current pricing.

1. Search for Fello AI in the App Store, install it, and open the app. Click outside the subscription screen if you want to try the free tier first.
2. In the main window, open the Model menu (top right) and choose Grok.
3. Type your question in the text field. To attach a file (e.g. for summarization), use Attach Files and press Return.

3. Use macos-grok-overlay

macos-grok-overlay is a small open-source app that puts grok.com in its own window. You open or hide it with a keyboard shortcut. It’s a dedicated Grok window that floats on top of your other apps. You don’t need a browser tab open.

The app runs in the background and uses Option + Space to show or hide the Grok window. Log in to grok.com once in that window. After that, Grok is one key combo away.

You can install it two ways. Easiest: download the DMG from the GitHub repo and drag the app into Applications (works on both Intel and Apple Silicon).

Or, if you have Python and pip, use the steps below. The first time you launch it, macOS will ask for Accessibility permission so the app can listen for Option + Space. You have to allow that or the shortcut won’t work.

1. In Terminal, run: python3 -m pip install macos-grok-overlay then press Return.
2. To start it at login, run: macos-grok-overlay --install-startup and press Return.
3. Launch the app, grant Accessibility when prompted, then log in to grok.com in the window that opens. After that, press Option + Space anytime to show or hide the Grok overlay.

4. Use Ollama and run Grok locally

Ollama lets you run large language models (LLMs) on your own Mac or PC. Install it, pull the models you want, then chat from the terminal or a web UI. No xAI or X account is needed. For a full walkthrough (including Open WebUI), see How to Run Chat Assistant that Works Offline.

Here you download a Grok model and run it locally. Community-quantized Grok 2 models are on Ollama, e.g. MichelRosselli/grok-2. After installing Ollama, pull and run a variant with:

ollama run MichelRosselli/grok-2

Heads up: these Grok 2 models are huge. Even smaller quantized builds are around 82 to 100GB. Full-quality can be 160GB or more.

You’ll want a strong machine: at least 32GB RAM (64GB or more for the bigger quants), 100GB+ free storage, and ideally a high-end GPU with plenty of VRAM (e.g. 24GB+) for faster inference. On Apple Silicon, unified memory helps; 64GB or 96GB is more realistic for the big models.

If your Mac only has 8 to 16GB RAM and limited storage, this route is probably not worth it. The options above are much lighter.

Alternative ways to run Grok on your Mac

As of this writing there’s no word on a native Grok or X app for Mac. The four methods above all need a third-party app or a big model download.

If you want to use Grok on your Mac with zero installs, the browser is a solid option. It’s the fastest.

Log in to X in your browser and open x.com/grok. Then make it easy to get back: bookmark the page (Cmd + D in Safari or Chrome). In Safari you can also add the page to your Dock so it opens like an app. With x.com/grok open, go to File → Add to Dock. A Grok icon shows up in the Dock; click it whenever you want Grok without digging through bookmarks.

1. In your browser, go to x.com and log in.
2. Open x.com/grok.
3. Bookmark the page (Cmd + D), or in Safari use File → Add to Dock so you can open Grok with one click from the Dock.

Conclusion

There’s no official Grok or X app for Mac yet, but you’ve got options: launchers like Raycast, a dedicated Grok window (macos-grok-overlay), all-in-one apps like Fello AI, or running Grok locally with Ollama if your machine is up to it. Or just use x.com/grok in the browser and add it to your Dock.

Pick whatever fits how you work and how much you’re okay installing.

Frequently Asked Questions

The post How to Use Grok on Mac – Complete Guide appeared first on Hongkiat.

• Screenshots save to your Desktop by default, creating clutter
• Filenames are based on timestamps (e.g., “Screen Shot 2026-01-09 at 2.30.00 PM.png“), which aren’t descriptive

This post will show you how to solve both problems by automatically saving screenshots to a custom folder with meaningful, descriptive filenames.

Why does this matter?

Over time, you’ll accumulate tons of screenshots with unhelpful filenames. Finding the right one becomes difficult. You might tell yourself you’ll organize and rename them later, but let’s be honest – that rarely happens.

Eventually, the clutter becomes overwhelming and you delete them in bulk, often losing screenshots you actually need.

What we’re building

Here’s what we’ll do using Mac’s native features (no additional apps required): Every time you take a screenshot, your Mac will automatically save it to a custom folder, analyze the content, and give it a short, descriptive filename.

Basically, you’ll turn messy screenshot files like these (left) into organized, descriptive ones like these (right).

Getting started

This setup takes about 5-10 minutes and requires Mac’s Terminal and Shortcuts apps.

System requirements:

• Apple silicon Mac (M1, M2, or later)
• Latest macOS version
• Apple Intelligence enabled

Now, let’s get started.

1. Specify a folder for screenshots

First, let’s configure macOS to automatically save all screenshots to a specific folder.

Steps:

1. Create a folder named “Screenshots” (or any name you prefer)
2. Open the Terminal app
3. Type the following command followed by a space (don’t press Enter yet):

   defaults write com.apple.screencapture 

   

4. Drag and drop your folder from Finder into the Terminal window – this automatically fills in the folder path

   

5. Press Enter
6. Apply the changes by running:

   killall SystemUIServer

That’s it! Exit the Terminal app and take a few test screenshots. They should now save automatically to your designated folder.

2. Building the automation

Here’s what we’re building: whenever a screenshot is saved to your folder, it will be automatically analyzed and renamed with a meaningful, descriptive filename.

Steps:

1. Launch the Shortcuts app
2. Create a new Automation: Go to File > New Automation, select Folder, then click Next
3. In the next screen:
   • Click Choose Folder, navigate to your screenshot folder, and click Select
   • Under “When Any Items Is”, check Added
   • Check Run Immediately

   

4. Verify everything is correct (see screenshot below), then click Next

On the next screen, click “New Shortcut” to continue, and then you’ll be directed to the shortcut’s interface.

Follow these below steps carefully to build the shortcut:

1. Add “Repeat with Each” action:

• In “Search Actions” (top right), search for “Repeat with Each” and double-click to add it



• Click the blue “Items”, select “Shortcut Input” from the dropdown
• Click “Shortcut Input” again, then select “Added files”

  

2. Add “Get Images from Input” action:

• Search for “Get Images from Input” and double-click to add it
• Drag it between “Repeat with…” and “End Repeat”

Check your shortcut against the screenshot below to verify it’s correct.

3. Add “Use Model” action:

• Search for “Use Model” and add it to the panel

  

• Click the textbox containing “Images”, clear it, and paste this prompt:

Analyze the image and provide a short, simple descriptive name based on these rules:
* "Length:" Use between 3 to 5 words.
* "Format:" Do not end the description with a period (.).
* "Style:" Keep it clear, concise, and descriptive of the main subject.

• At the end of the textbox, right-click and select “Insert Variable > Images”

4. Add “Rename File” action:

• Search for “Rename File” and add it above “End Repeat”

  

• Right-click “Response” and change it to “Repeat Item”
• Right-click “Name” and change it to “Response”

That’s it! Take a test screenshot. The first time, you’ll see a permission prompt – click Okay to allow access to your screenshot folder.

Take a few more screenshots and watch them automatically get renamed with descriptive filenames in your designated folder.

Final thoughts

If the renamed screenshots aren’t exactly what you want, feel free to edit the prompt. With this automation quietly working in the background, your screenshots will be better organized, easier to search via Spotlight, and easier to identify at a glance.

The post Auto-Organize Mac Screenshots into Folder and Rename with AI appeared first on Hongkiat.

• Best plan for the price?
• Am I overpaying for apps I don’t use?
• How many AI / Generative Fill credits do I get?
• Do I need the full suite?

As a Photoshop user, Adobe’s marketing can feel overwhelming. Their website looks slick but hides crucial details about what you’re actually getting. Prices vary by region, AI credit allocations change without warning, and the differences between plans are buried in footnotes.

This guide is specifically for Photoshop users like you. All information is as updated as November 2025.

By the time you finish reading, you’ll know:

• The 4 plans that include Photoshop
• Photoshop plan vs Pro: what’s different?
• AI credits by plan
• When you run out of credits
• Downgrading without losing your work

No promos, no affiliate links, no upsell. Just the facts Photoshop users need to make the right choice and stop overpaying.

Let’s look at the only plans that include Photoshop.

The 4 Plans That Include Photoshop

Here’s what you need to know about the plans that actually include Photoshop (prices shown are the standard monthly rate when paid annually, before local taxes):

What Photoshop users need to know:

• You get the exact same Photoshop application in all four plans; there’s no “lite” version in cheaper plans.
• The main differences are in AI credits, cloud storage, and whether you get Lightroom Classic.
• If you only use Photoshop, the Single App plan saves you over $400/year compared to Pro.
• For photographers who edit in both Photoshop and Lightroom Classic, the Photography Plan is actually cheaper than the Photoshop-only plan.

Photoshop-Only Plan: What You Get

If you’re primarily a Photoshop user who rarely touches other Adobe apps, this is the plan designed specifically for you. It’s officially called:

Photoshop Single App Plan – US$22.99/mo (paid annually) or US$34.49/mo month-to-month

What you actually get:

• Full desktop Photoshop (exactly the same version as the US$60 plans)
• Lightroom (web and mobile versions only, not the full Lightroom Classic)
• Lightroom Classic is NOT included
• Adobe Fresco and Portfolio
• 100 GB cloud storage
• Generative AI features inside Photoshop (Generative Fill, Generative Expand, Text-to-Image)

Important catch:

Generative AI credits on this plan are tiny compared to the big plans.

• If you subscribed before the recent policy change → you still get 500 credits/month
• If you subscribed after the recent policy change → you only get 25 credits/month

25 credits means roughly 25 Generative Fills or 25 AI-generated images per month. Once they’re gone, the features don’t stop working, but they become noticeably slower (Adobe puts you in the “slow queue”).

Bottom line: If you only need Photoshop and you’ll use Generative Fill lightly (a few times a week at most), the Photoshop Single App plan is the clear winner. You’ll save ~US$450–500 per year compared to Creative Cloud Pro.

AI Credits by Plan

Here’s exactly what Photoshop users get with each plan – no marketing fluff:

What counts as 1 credit? (Adobe’s official rates)

• 1 credit → 1 standard Generative Fill / Expand / Text-to-Image (up to 2048×2048 px)
• 25–100 credits → 1 short AI video clip (3–5 seconds in Premiere or Firefly)
• 4–8 credits → 1 high-resolution or complex generation

Pro tip:

Creative Cloud Pro is the only individual plan that gives “unlimited standard generations” on top of the 4,000 credits. That means basic Text-to-Image and Generative Fill never slow down, even if you somehow burn through all 4,000 credits (almost impossible for one person).

What Those Credits Get You

Numbers on a screen don’t mean much until you see real examples. Here’s what the monthly allowance actually translates to in daily life (using Adobe’s current credit costs):

Creative Cloud Pro – 4,000 credits + unlimited standard

• ≈ 4,000 normal Generative Fills or text-to-image generations
• ≈ 160 five-second AI video clips (if you use the expensive video tools)
• ≈ 1,000 higher-quality or 4K upscale generations

Real life: You can literally generate images all day, every day and never hit a wall. Most solo creators never use more than 1,000–1,500 credits in a month.

All Apps – 1,000 credits

• ≈ 1,000 regular images or fills
• ≈ 40 short AI videos

Real life: Fine for full-time designers or YouTubers who use AI daily but not obsessively. Heavy users run out around day 20.

Photoshop Plan (new subscriber) – 25 credits

• Exactly 25 Generative Fills or 25 text-to-image generations per month

Real life: About one AI edit per day if you spread it out. After that, everything switches to the slow queue (can take 30–60 seconds instead of 3–5 seconds).

Photoshop Plan (old subscriber) – 500 credits

• Still 500 decent-quality generations per month

Real life: Plenty for most months unless you’re doing client work with heavy AI.

Photography Plan – 250 to 1,000 credits

• Enough for removing backgrounds, extending skies, or object removal on hundreds of photos per month.

Bottom line: If you ever find yourself thinking “I wish Generative Fill was faster” or “I hit my limit again,” you’re on the wrong plan.

Photoshop Plan vs Pro: What’s Different?

Quick verdict in plain English:

Choose Photoshop Plan if:

• You open Photoshop 99% of the time
• You use Generative Fill a few times a week at most
• You want to save ~US$450 a year

Choose Creative Cloud Pro if:

• You regularly use 3+ Adobe apps
• You generate dozens (or hundreds) of AI images/videos every month
• You hate waiting even 10 extra seconds for a generation
• You need the extra 900 GB of cloud storage

Most people who think they “need” Pro actually don’t. Try the Photoshop Plan first. You can upgrade anytime in under 2 minutes with zero downtime.

Check Your AI Credits (30 Seconds)

You don’t have to guess how many credits you have left; Adobe shows the exact number in two easy places.

Method 1: Fastest (works on any device)

1. Open a browser and go to https://account.adobe.com
2. Sign in with your Adobe ID
3. Click your profile picture (top-right corner)
4. Look for the box that says Generative credits – it shows something like “2,847 of 4,000 remaining” and a progress bar
5. (It updates in real time and resets on your billing date.)

Method 2: Inside Photoshop or Firefly

• In Photoshop: Help menu → Generative Credits (takes you to the same page)
• In Firefly web (firefly.adobe.com): click your avatar (top-right) → the counter is right there

That’s literally it. No digging through menus, no support chat needed.

Pro tip:

Bookmark account.adobe.com/plans and check it once a week if you’re a heavy AI user. Many people get a nasty surprise at the end of the month because they never looked.

When You Run Out of Credits

Adobe does not completely lock you out of Generative AI when your monthly credits hit zero, but things definitely change:

In practice:

• Casual users on the Photoshop Plan rarely notice the slowdown because they only do a handful of generations per month.
• Heavy users feel it instantly: waiting a minute for every Generative Fill kills the workflow.

The slowdown is Adobe’s way of nudging you toward either Creative Cloud Pro or the credit add-on packs.

Buying Extra Credits: Worth It?

If you ever run out and don’t want the slow queue (or you’re on Pro but somehow burned through 4,000 credits doing video), Adobe sells add-on credit packs. These are monthly subscriptions (not one-time purchases) and stack on top of your plan’s included credits.

Current prices (in USD before local tax):

Real-world math most people care about:

• If you find yourself buying the 2,000-credit pack every month, you’re spending ~US$30 extra → total US$53/mo on a Photoshop Plan. At that point, just upgrade to Creative Cloud Pro (US$59.99) and get unlimited + all apps.
• The 100-credit pack is almost never worth it; it’s the most expensive per generation by far.

You can turn these add-ons on/off anytime from account.adobe.com → Plans & Products → Manage plan → Add-ons.

Downgrading Without Losing Your Work

Yes, you can drop from Creative Cloud Pro (or All Apps) down to the cheaper Photoshop Single App plan at any time, and you won’t lose files, presets, brushes, or Lightroom catalogs. Here’s the safe way to do it:

1. Wait until the day after your current billing cycle ends (If you cancel mid-cycle on an annual plan, Adobe will still charge you the 50% early-termination fee on the remaining months, so wait.)
2. Log in at https://account.adobe.com/plans
3. Find your active plan → click Manage plan → Change plan
4. Choose Photoshop (the single-app option, US$22.99/mo)
5. Pick the same billing cycle you’re on now (annual or monthly)
6. Confirm. The change takes effect at the end of your current paid period

What stays the same:

• All your cloud files (they just cap at 100 GB instead of 1 TB; anything over 100 GB stays accessible but you can’t add more until you’re under the limit)
• All installed apps continue working until the downgrade date
• Lightroom Classic catalogs, Photoshop brushes, presets, fonts: everything stays on your computer

What you lose immediately on downgrade day:

• Access to Illustrator, Premiere, After Effects, InDesign, etc.
• The extra 900 GB of cloud storage
• The 4,000 (or 1,000) AI credits → you drop to the Photoshop Plan’s 25–500 credits

Pro tip:

Before you downgrade, download anything important from Creative Cloud storage to your hard drive or another cloud service. Once you’re under 100 GB, you’re golden forever.

30-Second Decision Guide

Find your situation below to instantly see which plan matches your actual Photoshop usage:

The bottom line for Photoshop users:

Most Photoshop users who subscribe to Creative Cloud Pro are overpaying for features they rarely or never use. Unless you’re heavily using AI features daily or need multiple Adobe apps, the Photoshop Single App plan will give you the exact same Photoshop experience at less than half the price.

If you’re a photographer who uses both Photoshop and Lightroom, the Photography Plan is an even better deal.

Take a moment to review your actual usage, check your AI credit balance, and make sure your subscription matches how you actually use Photoshop. Your creative budget will thank you.

The post Which Creative Cloud Plan Fits Your Photoshop Use? appeared first on Hongkiat.

While OpenClaw offers seamless, out-of-the-box support for industry giants like OpenAI, Anthropic, and Google Gemini, unfortunately, it currently lacks native integration for DeepSeek.

This can be a significant hurdle because DeepSeek provides a model, DeepSeek v3, that rivals GPT-5, but at a staggering 95% lower cost.

In this guide, we’ll walk you through the steps, applying a few manual configurations, so we can have the best of both sides: OpenClaw’s automation capabilities with DeepSeek’s cost-efficient intelligence.

Let’s get started.

Prerequisites

Before we move further, make sure that you have the following ready.

• Node.js (v22 or higher) and NPM
• DeepSeek API key

Once you have them ready, you can proceed to install and set up OpenClaw.

Step 1: Installing OpenClaw

First, fire up your terminal and then hit the following command to install OpenClaw:

npm install -g openclaw

Note: This installation step might take a while depending on your internet connection speed.

Step 2: Run Onboarding

Next, we need to run the onboarding process.

openclaw onboard --install-daemon

This will install the OpenClaw daemon and guide you through selecting models, providers, and communication channels.

In this example, we are going to focus on integrating DeepSeek. When prompted, use the left and right arrow keys to toggle between options, and hit Return to select the desired option. Here’s how you can answer the following questions:

• I understand this is powerful and inherently risky. Continue? Yes
• Onboarding mode. Quickstart
• Model/auth provider. Skip for now
• Filter models by provider. Minimax (Simply because it has 2 models, which makes it easier to select and cleanup later)
• Default model. minimax/MiniMax-M2
• Select channel. Skip for now
• Configure skills now? No (We can always reconfigure it later)
• Enable hooks? Skip for now (hit Space to select)
• How do you want to hatch your bot? Do this later (Right now, it won’t work since we haven’t configured DeepSeek yet)

Once you see Onboarding complete. Use the dashboard link above to control OpenClaw., you can hit Ctrl + C to exit the onboarding process, and proceed to our next step.

Step 3: Configure DeepSeek Models

We’ll need to modify the configuration file which is located in the ~/.openclaw/openclaw.json file. We’ll begin with defining DeepSeek models by editing the models section in the configuration file.

Now, let’s add the DeepSeek models configuration to the configuration file:

{
    "models": {
        "mode": "merge",
        "providers": {
            "deepseek": {
                "baseUrl": "https://api.deepseek.com/v1",
                "apiKey": "${DEEPSEEK_API_KEY}",
                "api": "openai-completions",
                "models": [
                {
                    "id": "deepseek-chat",
                    "name": "DeepSeek Chat (v3.2)",
                    "reasoning": false,
                    "input": [
                    "text"
                    ],
                    "cost": {
                        "input": 2.8e-7,
                        "output": 4.2e-7,
                        "cacheRead": 2.8e-8,
                        "cacheWrite": 2.8e-7
                    },
                    "contextWindow": 128000,
                    "maxTokens": 8192
                },
                {
                    "id": "deepseek-reasoner",
                    "name": "DeepSeek Reasoner (v3.2)",
                    "reasoning": true,
                    "input": [
                    "text"
                    ],
                    "cost": {
                        "input": 2.8e-7,
                        "output": 4.2e-7,
                        "cacheRead": 2.8e-8,
                        "cacheWrite": 2.8e-7
                    },
                    "contextWindow": 128000,
                    "maxTokens": 65536
                }
                ]
            }
        }
    }
}

Notice that the apiKey is using an environment variable ${DEEPSEEK_API_KEY}. This is to ensure that the API key is not exposed in the configuration file. Later we’ll need to set this environment variable before running OpenClaw.

Step 4: Configure Agents

Next, we need to configure the agents section, which sets the list of models and the default model to be used by the agent.

In this case, we’ll modify the agents section to use DeepSeek models that we’ve just defined in the previous step, as follows:

{
    "agents": {
        "defaults": {
            "model": {
                "primary": "deepseek/deepseek-chat"
            },
            "models": {
                "deepseek/deepseek-chat": {},
                "deepseek/deepseek-reasoner": {}
            },
            "workspace": "~/.openclaw/workspace",
            "compaction": {
                "mode": "safeguard"
            },
            "maxConcurrent": 4,
            "subagents": {
            "maxConcurrent": 8
            }
        }
    }
}

Step 5: Set Environment Variable

Now, we need to set the environment variable DEEPSEEK_API_KEY to the value of our DeepSeek API key.

Linux and macOS

On Linux and macOS, you can run the following command in your terminal:

export DEEPSEEK_API_KEY="your_api_key_here"

To persist the API key across sessions, you can also add the above line to your ~/.bashrc, ~/.zshrc, or /etc/environment file.

Don’t forget to replace your_api_key_here with your actual DeepSeek API key. And if you’ve just added it in one of the files, you’ll need to restart your terminal for the changes to take effect.

Windows

On Windows, you can set the environment variable for the current session in Command Prompt:

set DEEPSEEK_API_KEY=your_api_key_here

Or, setx, for example:

setx DEEPSEEK_API_KEY "your_api_key_here"

Step 6: Ensure DeepSeek Models are on the List

Now that we’ve configured the models and set the environment variable, we can verify that the DeepSeek models are available to OpenClaw by running the following command:

openclaw models list

You should see the following output:

Step 7: Hatch Your First Agent

Everything is now configured. We can now hatch our first agent.

In this case, I’m going with TUI as the interface. So we run:

openclaw tui

This will start the TUI interface where you can chat with the agent. And we can see the model that’s currently being used is deepseek/deepseek-chat.

Note: If you have a previously active session or have previously installed OpenClaw, you need to restart the gateway before running a new TUI session. Run the following command:

openclaw gateway restart

Ensure you do this before running a new TUI session.

Conclusion

And there you have it! You’ve successfully bridged OpenClaw with DeepSeek.

Now it’s time to put your new agent to work. Whether it’s managing complex workflows, handling files, or automating tasks and messaging.

You’re all set to do more for less.

The post How to Use OpenClaw with DeepSeek appeared first on Hongkiat.

The Abilities API provides a standardized way for WordPress core, plugins, and themes to define their capabilities in a format both humans and machines can read.

In this post, we’ll explore what the Abilities API is, why it matters, and how to use it in practice with some code examples.

Without further ado, let’s get started.

What is Abilities API?

The Abilities API is a new feature in WordPress that acts like a dictionary of everything a site can do. Before this, there was no simple or consistent way for plugins or external tools to discover a site’s available features. Functionality was often scattered across hooks, REST API endpoints, and various pieces of custom code.

With the Abilities API, automation tools, AI assistants, and other plugins can more easily understand how to interact with a WordPress site. Tools like AI agents, Zapier, or n8n can simply ask WordPress, “What can you do?” and receive a structured list of abilities.

This API also makes cross-plugin collaboration much cleaner. Plugins can call each other’s abilities directly instead of relying on hidden hooks or fragile workarounds.

Getting Started

To use the Abilities API, the first step is to register a new ability. This is typically done within your plugin or theme. An “Ability” should contain:

• A unique name that consists of only lowercase alphanumeric characters, dashes, and forward slashes e.g. hongkiatcom/create-invoice
• A human-readable description and label.
• A defined output and input schema.
• A permission check.

Here is a simple example of how we register an ability that analyzes a site and returns some metrics.

In this example, we call it hongkiatcom/site-analytics-summary. It doesn’t require any inputs and returns an object containing three metrics: visits, signups, and sales. The ability can only be executed by users with the manage_options capability.

add_action( 'wp_abilities_api_init', function () {
    if ( ! function_exists( 'wp_register_ability' ) ) {
        return;
    }
    
    wp_register_ability(
        'hongkiatcom/site-analytics-summary',
        [
            'label'       => __( 'Get Site Analytics Summary', 'myplugin' ),
            'description' => __( 'Returns a simple overview of site performance.', 'myplugin' ),
            'input_schema' => [
                'type'       => 'object',
                'properties' => [],
            ],
            'output_schema' => [
                'type'       => 'object',
                'properties' => [
                    'visits'  => [ 'type' => 'integer' ],
                    'signups' => [ 'type' => 'integer' ],
                    'sales'   => [ 'type' => 'integer' ],
                ],
            ],
            'permission_callback' => function () {
                return current_user_can( 'manage_options' );
            },
            'execute_callback' => function () {
                return [
                    'visits'  => 1473,
                    'signups' => 32,
                    'sales'   => 5,
                ];
            },
        ]
    );
});

Here is another example of registering an ability that processes an order. This ability takes in customer ID, product SKUs, and a payment token as input, and returns the order ID, status, and a confirmation message as output.

add_action( 'init', function() {
    if ( ! function_exists( 'wp_register_ability' ) ) {
        return;
    }

    wp_register_ability( 'hongkiatcom/process-order', [
        'description' => 'Handles payment, creates an order record, and sends a confirmation email.',
        'execute_callback'    => function () {
            // Implementation of order processing logic goes here...
        },
        'input_schema' => [
            'type'       => 'object',
            'properties' => [
                'customer_id' => [
                    'type'        => 'integer',
                    'description' => 'The ID of the customer placing the order.',
                ],
                'product_skus' => [
                    'type'        => 'array',
                    'description' => 'An array of product SKUs (strings) to be included in the order.',
                    'items'       => [ 'type' => 'string' ],
                ],
                'payment_token' => [
                    'type'        => 'string',
                    'description' => 'A secure, single-use token from the payment gateway.',
                ],
            ],
            'required' => [ 'customer_id', 'product_skus', 'payment_token' ],
        ],
        'output_schema' => [
            'type'       => 'object',
            'properties' => [
                'order_id' => [
                    'type'        => 'integer',
                    'description' => 'The ID of the newly created order post.',
                ],
                'order_status' => [
                    'type'        => 'string',
                    'description' => 'The resulting status of the order (e.g., "processing", "pending").',
                ],
                'message' => [
                    'type'        => 'string',
                    'description' => 'A confirmation message.',
                ],
            ],
        ],
    ] );
} );

Executing Abilities

Registering an ability doesn’t do much on its own. We also want to execute it and get the result.

In PHP

In PHP, using an ability is straightforward. WordPress provides a function wp_get_ability() to retrieve the ability object by name, and then you call the ability’s execute() method.

Here’s how you might execute the site-analytics-summary ability we registered:

$ability = wp_get_ability( 'hongkiatcom/site-analytics-summary' );

if ( $ability ) {
    $result = $ability->execute();
}

If the ability requires inputs such as in the process-order example, you would pass an associative array of inputs to the execute() method:

$ability = wp_get_ability( 'hongkiatcom/process-order' );
if ( $ability ) {
    $inputs = [
        'customer_id'  => 123,
        'product_skus' => [ 'SKU123', 'SKU456' ],
        'payment_token'=> 'tok_1A2B3C****',
    ];
    $result = $ability->execute( $inputs );
}

Notice that we didn’t have to manually handle permission checks or input validation here. If the current user didn’t have permission, or if we passed a wrong type of input, execute() would fail gracefully. It wouldn’t run the callback and would return an error or false. This is thanks to the schemas and permission callback we set up during registration. It makes using the ability safe and predictable.

Now that we’ve seen how to declare and use abilities on the back-end, let’s look at how abilities can be accessed from JavaScript, which covers front-end use cases and external integrations.

In JavaScript

The Abilities API supports REST API out of the box, but you need to make sure that you enable the show_in_rest on the Ability registration, for example:

add_action( 'wp_abilities_api_init', function () {
    if ( ! function_exists( 'wp_register_ability' ) ) {
        return;
    }
    
    wp_register_ability(
        'hongkiatcom/site-analytics-summary',
        [
            ...
            'execute_callback' => function () {
                return [
                    'visits'  => 1473,
                    'signups' => 32,
                    'sales'   => 5,
                ];
            },
            'meta' => [
                'show_in_rest' => true,
            ],
        ]
    );
});

Once that’s set, the ability becomes accessible under a special REST namespace wp-abilities/v1/{ability-namespace}/{ability-name}. In our example above, the full REST endpoint to execute the ability would be: /wp-json/wp-abilities/v1/hongkiatcom/site-analytics-summary.

This means external applications or your own front-end code can execute abilities by sending HTTP requests without you writing any extra REST handler code. WordPress takes care of that based on the info you provided.

WordPress is also introducing a JavaScript client library for the Abilities API, making it much easier to call abilities from the browser or any headless JS setup. Instead of writing manual fetch() calls, you can simply use built-in helper functions to list, fetch, and run abilities.

First, we’d need to install the library with NPM:

npm i @wordpress/abilities

Then, we can use it like this in our JavaScript application:

useEffect(() => {
   executeAbility( 'hongkiatcom/site-analytics-summary' ).then( ( response ) => {
       setResponse( response ); // Store the result in state.
   } );
}, []);

Wrapping Up

The Abilities API introduces a new way for WordPress to describe what it can do in a clear and more standardized format. This improves the interoperability of your site and allows it to work more naturally with AI assistants or automation tools.

In this article, we’ve just scratched the surface of what’s possible with the Abilities API. As more plugins and themes adopt it, we can expect a richer ecosystem where capabilities are easily discoverable and usable across different contexts.

And in the next article, we’ll see how we can integrate your WordPress site with external applications like Claude or LM Studio using the Abilities API.

So stay tuned!

The post How to Use the WordPress Abilities API (Register & Execute) appeared first on Hongkiat.

Despite the name, Antigravity won’t actually make your code afloat. But it might change how you write code. Rather than typing every line yourself, you can simply explain what you want to build, and an AI agent will plan the steps, write the code, and improve it for you. So you can focus on the idea instead of the implementation.

In this post, we’ll explore a bit more what Google Antigravity is, how it works, and why developers are starting to pay attention to it.

Installation

Let’s first get started with the installation.

Google Antigravity is available on all major platforms – macOS, Windows, and Linux. You can download the installer from the official Google Antigravity website.

If you’re on macOS, you can also download it from the Homebrew Cask.

After you’ve downloaded the installer, run it and follow the on-screen instructions. Once installed, launch Google Antigravity from your applications menu or desktop shortcut.

Upon the initial launch, you will be prompted with several questions, such as whether you’d like to import configuration from other compatible editors like VS Code and Cursor, the editor theme, and the workflow setup you’d like to run:

There are 4 options, as we can see above.

Although the recommended setup is Agent-assisted development, I prefer to be very hands-on with my code, so I selected Review-driven development. This mode lets you always review and approve the code changes suggested by the AI agent before applying any changes.

This setting also turns off the Terminal execution policy. I think this is a safer option, since I don’t want the AI agent to run any terminal commands without my approval either.

Again, you’re free to keep the default or fully customize the setup in the settings.

On the last step, you will be asked to log in to your Google Account.

First Impression

Google Antigravity is built on top of Visual Studio Code. So even though there are several tweaks that Google made, if you’ve been using Visual Studio Code, you will immediately feel at home. The interface is clean and intuitive, with a sidebar for file navigation, a main editor area, and a terminal at the bottom.

On the right side, you will find the prompt input where you can interact with the AI agent. And there are two modes you can choose to interact with the AI agent: Planning mode and Fast mode.

Planning Mode

I think Planning Mode is best when you’re working on something big or complex. So instead of jumping straight into code, the AI first pauses and creates a clear plan.

For example, if you ask it to build a WordPress plugin, it will outline steps like creating the directories, files, and outlining which WordPress functions and hooks that it’s going to use in the plugin.

This gives you a chance to review the approach, make changes, and stay in control before any code is written.

Once you think it’s good you can hit the Proceed button to continue. Or, submit a review for any changes you’d like to see in the plan.

Aside from the implementation plans that we saw here, Google may also generate task lists, screenshots, and browser recordings, depending on what you’re trying to build.

Fast Mode

Whereas in Fast Mode, the AI agent will proceed immediately with creating the plugin directory, files such as the PHP and readme.txt file, and add the functions and hooks without outlining the plan.

You can still review the code and accept it if you like the output, or request changes.

Agent Manager

The Agent Manager is a unique feature of Google Antigravity that changes how you work as a developer. Instead of being hands-on and writing everything line by line, you become more like a project architect.

Through what Google calls the “Mission Control” dashboard, you will define high-level goals and delegate tasks to AI agents. These agents handle the detailed planning and execution for you, so you can focus more on direction and decisions rather than implementation.

To open it up, find Open Agent Manager at the top right of the window, as you can see below.

The Agent Manager looks similar to common AI chat interfaces, where you can see the prompt input right at the center of the screen.

On the left side, you will find several sections:

Inbox: This is where you can see all your ongoing and past conversations with the Agent.

Workspaces: This is where you can manage different projects and apply outputs from the Agent to specific projects.

Playground: This is where you can experiment with different prompts and see how the Agent responds without affecting your main projects. If you like the output, you can easily transfer it to one of your workspaces.

Starting New Conversation

Let’s try starting a new conversation with the Agent. Click on the New Conversation button at the top left of the Agent Manager. Then, you can choose whether you’d like to start your new conversation in a specific Workspace, or in a Playground.

I’d choose to start in the Playground so I can experiment freely without affecting any projects.

In this case, I’d like to ask to create a new script to retrieve a path for a plugin in WordPress.

Within the Playground, Google Antigravity will create an isolated workspace directory outside the main ones. You can continue to iterate on the outputs in the Playground.

If you feel the script is ready and you’d like to move to a Workspace, you can click on the directory at the top right of the window and select the directory where your workspace resides.

This will move all the files created in the Playground to the selected Workspace.

Wrapping up

Google Antigravity is an exciting new tool that might change how we write code. By allowing us to focus on high-level ideas and delegating the implementation details to AI agents, it has the potential to significantly speed up development workflows.

It’s currently in public preview and is free for individual users with very generous limits, so I encourage you to try it out and see how it fits into your development process.

In the next article, we’ll explore how to further customize Google Antigravity and how to secure your projects when working with AI agents.

Stay tuned!

The post A Look into Google Antigravity appeared first on Hongkiat.

But as projects get bigger, the huge number of utilities can become overwhelming, leading to long class lists, slower development, and a constant need to look up class names. So how do we keep the speed and flexibility without getting buried under the class chaos?

In this article, we’ll explore five essential tools that can help you stay productive while working with Tailwind CSS. These tools will help you manage your classes better, speed up your workflow, and keep your code clean and maintainable.

Let’s check them out!

1. VSCode Extensions

If you’re using a code editor like VSCode, you should install the Tailwind CSS Intellisense. This extension provides intelligent suggestions as you type, helping you quickly find the right utility classes without having to remember them all.

On top of that, the extension also offers features like linting for your Tailwind CSS code. This can significantly speed up your development process and reduce errors.

Another extension that I would suggest is Tailwind Fold. It is another useful extension that helps you manage long class lists by allowing you to collapse and expand them. This keeps your code clean and makes it easier to navigate through your HTML files.

2. Code Linting Tools

Linting and proper formatting are essential parts of maintaining code quality, and there’s one tool that I would recommend if you’re working with Tailwind CSS: the prettier-plugin-tailwindcss.

This Prettier Plugin is an official plugin from the Tailwind CSS team that automatically sorts your classes in a consistent order whenever you format your code.

On top of that it also removes duplicated classes, unnecessary whitespace, and ensures that your Tailwind CSS code is clean.

To install it, run:

npm install -D prettier prettier-plugin-tailwindcss

Then, update the Prettier config in your project to include prettier-plugin-tailwindcss.

{
  "plugins": ["prettier-plugin-tailwindcss"]
}

After you’ve configured it, I’d recommend installing the Prettier – Code formatter extension, if you’re using VSCode. This extension will allow you to format your code directly from VSCode using Prettier, as well as reporting any formatting issues.

3. Tailwind Merge

When creating reusable components with Tailwind CSS, like a Button that would expect custom classes, you’ll likely run into class conflicts. For example, what happens if a component has a default p-2 but someone passes p-5 through className?

Since Tailwind utilities are atomic, both classes end up in the final output. This is exactly the messy problem that the tailwind-merge package solves beautifully.

It is a smart little utility that cleans up conflicting classes automatically. It looks at all the styles you pass in, groups anything that conflicts, like that p-2 vs p-5, and returns only the correct one—based on a simple rule: the last class wins. For example:

import { twMerge } from 'tailwind-merge';

const classes = twMerge('p-2', 'p-5');
console.log(classes); // Output: 'p-5'

This makes component libraries in React, Vue, or Svelte much easier to manage, allowing you and the users to freely override styles without worrying about unexpected results.

4. Tailwind Variants

Another thing that can get messy is when you start adding different styles based on props in your reusable component. For example, a button might need multiple versions such as different sizes, colors, or states like disabled or loading.

tailwind-variants helps solve this problem by giving you an easy and organized way to define those style variations without all the clutter. Let’s take a look at an example below:

import { tv } from 'tailwind-variants';

const button = tv({
  // Base classes that apply regardless of variants
  base: 'font-semibold rounded-lg shadow-md transition ease-in-out duration-150',
  
  // Define the available variants
  variants: {
    // 1. Variant for color/intent
    intent: {
      primary: 'bg-blue-500 hover:bg-blue-600 text-white',
      secondary: 'bg-gray-200 hover:bg-gray-300 text-gray-800',
    },
    // 2. Variant for size
    size: {
      sm: 'py-1 px-2 text-sm',
      lg: 'py-3 px-6 text-lg',
    },
    // 3. Boolean variant for full width
    fullWidth: {
      true: 'w-full',
    },
  },
  
  // Define default values if no prop is provided
  defaultVariants: {
    intent: 'primary',
    size: 'lg',
  },
});

In this example, we set the base styles for the button, then defined variants for intent (color), size, and a boolean for full width. We also set default variants to ensure the button has a consistent look when no specific props are provided.

Inside your component, you call the button function with the desired props, and it automatically generates the correct class string:

// Example 1: Use defaults
const classes1 = button();
// Result: "font-semibold rounded-lg shadow-md ... bg-blue-500 hover:bg-blue-600 text-white py-3 px-6 text-lg"

// Example 2: Override defaults
const classes2 = button({ intent: 'secondary', size: 'sm' });
// Result: "font-semibold rounded-lg shadow-md ... bg-gray-200 hover:bg-gray-300 text-gray-800 py-1 px-2 text-sm"

// Example 3: Use the boolean variant
const classes3 = button({ fullWidth: true });
// Result: "font-semibold rounded-lg shadow-md ... (primary/lg styles) w-full"

5. Tailwind Config Viewer

As your Tailwind project grows, your config file can become large and difficult to navigate. With custom colors, spacing, utilities, and breakpoints, it’s easy for developers and designers to forget what’s available or where to find it. Searching through the file for a class name or color code wastes time and often leads to mistakes or hard-coded values.

This is where tailwind-config-viewer comes in. It’s a helpful NPM package that creates a visual style guide from your project’s tailwind.config.js file.

Instead of digging through the config file manually, you get a clean, searchable web interface that shows all your custom settings including the colors, spacing, typography, and breakpoints, right in your browser.

To get started, you can run the following to install it:

npm i tailwind-config-viewer -D

Then, add a custom script in your package.json file.

"scripts": {
  "tailwind-config-viewer": "tailwind-config-viewer -o"
}

Now, you can run npm run tailwind-config-viewer, and it will launch a local server displaying your Tailwind CSS configuration in a user-friendly format, as seen below:

Wrapping Up

Tailwind CSS is a powerful framework, but managing its utility-first approach can get overwhelming as projects grow. The tools we’ve explored in this article can significantly boost your productivity by simplifying class management, improving code quality, and enhancing your workflow.

We hope that these tools help you work more efficiently with Tailwind CSS and make your development process smoother and more enjoyable.

The post 5 Tailwind CSS Essential Tools to Boost Your Productivity appeared first on Hongkiat.