How do I push a task to my own AI agent from my phone?

You push a task to your own running AI agent from your phone with the Vilix AI Agent Inbox. From any client connected to your account, you send a message addressed to your agents and Vilix AI queues it until that agent's next read of memory. The next time the agent calls get_context (or a search, or get_project), your note is waiting in the inbox field of the response and the agent can act on it within its instructions and permissions. There is no new session to start and nothing to copy-paste. Here is how the mechanics work: how the inbox field works, the difference between normal and urgent delivery, and when the agent calls ack_message.

What the Agent Inbox actually does

The Agent Inbox is a push channel for your own agents. You write a message and choose who it is for, and Vilix AI queues it. It is delivered inside the inbox field of that agent's next memory read. It is not a real-time interrupt and does not wake a sleeping process. It is on the next read. If your agent is idle, the message waits until that agent next reads memory. For an always-on agent that reads memory each turn, delivery happens on its next turn.

Vilix AI is an MCP-native memory layer. Configured agents call get_context, compose a reply, call save_turn with that exact exchange, and send the saved reply. They also call tools such as the search functions, recent_messages, and get_project as they work. The Agent Inbox piggybacks on those reads: any of them returns your queued message in the inbox field. So the speed of delivery is the cadence of the agent's reads, not a separate notification system.

Normal vs urgent, and ack_message

An inbox message's urgency determines how often it is delivered.

• Normal urgency (the default) is delivered once per chat, then it's done. It's the right choice for a hand-off you only need the agent to see once, like starting the next task.

• Urgent is redelivered on every read, every chat, until the receiving agent calls ack_message to acknowledge it, or the message expires. Use it for something the agent must not miss, like stop work on the migration.

Messages have a time to live. The default is 24 hours and the maximum is 168 hours (7 days). You can hold up to 20 unexpired messages at a time. Bodies are Markdown, up to 2000 characters, so a hand-off can carry real detail and not just a one-liner.

You decide who gets the message

An inbox message can be scoped three ways, so that only the agents you mean get it:

• Global goes to all of your agents. Any of your agents that reads memory will see it.

• Scoped to a project or task you own, so only an agent working on that project or task picks it up.

• Scoped to one source or platform, like Claude Code, so only agents running on that tool see it.

A worked example: one line from your phone, picked up on the next read

Say you run an always-on agent that handles your deploys and is connected to Telegram through a harness like OpenClaw or Hermes. You're away from your desk, on your phone, when staging goes green. You open Telegram and ask your connected messaging agent: tell my coding agent the staging deploy is green, start the smoke tests. The sending agent must use the Vilix AI messaging tool to create the Agent Inbox item; a regular Telegram message doesn't do that.

That message lands in the Agent Inbox, scoped to the agent or project you chose. Minutes later the agent comes around to its next turn and calls get_context. Your note is there in the inbox field. The agent reads it, kicks off the smoke tests, and reports back, without you opening a laptop or starting a new session. If you mark it urgent, it keeps reappearing on every read until the agent calls ack_message, exactly what you want for something that must not slip through.

This is the same pattern as running one always-on agent across WhatsApp, Telegram, and Slack with shared memory, except here you're not chatting with the agent, but handing it work to pick up on its own. For an idea of how much an always-on agent accumulates over time, see the 12k-memories always-on agent case study.

Which tools can send and receive inbox messages

Any tool connected to Vilix AI as a custom MCP connector can send to the inbox and read from it. That covers ChatGPT, Claude, Claude Code, Cursor, Codex, Grok, Manus, GitHub Copilot, Windsurf, Lovable, and purpose-built agent harnesses like OpenClaw and Hermes, and you can wire up any custom agent yourself. Because the inbox rides ordinary memory reads, you don't add a new integration to receive messages. If an agent already reads Vilix AI memory, it already has an inbox.

The underlying setup is the MCP connection, authentication, and instructions that let an agent use Vilix AI memory. If you haven't set that up yet, the guide to adding memory to any agent with the Vilix AI MCP walks through it, and the runtime-specific posts for OpenClaw and Hermes cover them in detail.

Setting it up

The Agent Inbox is part of the same memory layer that works across ChatGPT, Claude, Cursor, Codex, and other AI tools. Connect and authenticate your supported clients at api.vilix.ai/mcp and then add Vilix AI's custom instructions or configure the agent loop. Your agents should call get_context, compose the reply, call save_turn with that exact exchange, and send the saved reply. Their memory reads also surface inbox messages addressed to them. The MCP memory server setup guide covers the connection step for each supported tool.

Vilix AI has a free tier to get started. Try Vilix AI free and push your first task to a running agent in a few minutes.

Frequently asked questions

How do I push a task to my own AI agent from my phone?

Send a message through the Vilix AI Agent Inbox from any client connected to your account, including one via a phone. Vilix AI queues it and delivers it inside the inbox field of your agent's next memory read, so the agent picks up the work on its own next turn without you starting a new session.

Is the Agent Inbox a real-time push notification?

No. The Agent Inbox is not a real-time interrupt and does not wake an idle process. It rides the agent's next memory read: the message waits until the agent next calls get_context, a search, recent_messages, or get_project, and then it appears in the inbox field. For an always-on agent that reads memory on every turn, that's effectively the next turn.

What is the difference between normal and urgent inbox messages?

A normal message (the default) is delivered once per chat and then it's done. An urgent message is redelivered on every read, every chat, until the receiving agent calls ack_message to acknowledge, or the message expires. Use urgent messages only for things the agent must not miss.

How long does an inbox message last?

Each message has a time to live that defaults to 24 hours, with a maximum of 168 hours (7 days). You can have up to 20 unexpired messages at once, and each body is Markdown up to 2000 characters.

Which AI tools can receive an inbox message?

Any agent connected to Vilix AI as a custom MCP connector, including ChatGPT, Claude, Claude Code, Cursor, Codex, Grok, Manus, GitHub Copilot, Windsurf, Lovable, and harnesses like OpenClaw and Hermes. Because delivery is piggybacked on ordinary memory reads, no extra integration is needed to receive messages.

Is there a free plan?

Yes. Vilix AI has a free tier with no time limit, plus a Pro plan at $19.99 per month with a 7-day full-Pro trial. You can get started for free without a credit card.