Theo Claw

So your worker can email people without borrowing your personal Gmail or Outlook, give it an agent identity. Open the worker’s Configure tab, find the Agent identity panel, and click Give it an address. That one step sets up the worker’s email address, and its calendar, and its contacts — with nothing to host, connect, or verify on your side. The panel shows the address it got, ready to copy.

One identity, not three. Its email, its calendar invitations, and its contacts all come from the same place — so when someone replies to a meeting invitation the worker sent, that reply lands in a mailbox the worker actually watches.

Set the name people see. The Name field in the same panel is what shows up on outgoing email and on calendar invitations. You can also set a reply-to address and a default time zone there.

Add a signature. Build a polished signature for free on SignForge (the Open SignForge button opens it in a new tab), paste the HTML back into the signature box, and it’s appended to everything the worker sends — with a live preview as you paste.

Prefer to send from your real mailbox instead? Leave the identity off and the worker sends through your connected Gmail or Outlook.

Large attachments. Files up to about 10 MB are attached directly. Bigger files are delivered as a secure download link inside the email instead — the recipient clicks through to a branded download page, and the send never fails because of file size. If the email provider hiccups on an attachment, the worker automatically retries with download links so the message still goes out.

Two-way email. When someone replies to a worker's email, the reply routes back to that worker and it answers from the same address. Each correspondent is a separate ongoing thread — the worker remembers the conversation, so a follow-up picks up right where it left off. Replying to the person who emailed is automatic (like texting back); emailing anyone else still follows the worker's approval policy.

Enable Send a text message in the worker’s Configure tab and a Text messages (SMS) panel appears. Click Search numbers (optionally filtering by US area code), pick a number, and add it for a flat $0.99/mo — the number becomes the worker’s own line. Release it anytime from the same panel and the monthly charge stops.

Two-way texting. Anyone can text the worker and it texts back from the same number. The worker remembers each person’s conversation separately — every phone number is its own ongoing thread — so a follow-up text picks up right where it left off. These text conversations stay private to the texting and never appear in the worker’s in-app Chat tab.

Replies are automatic. Texting a person back is the whole point, so the worker replies on its own — without waiting for your approval, even under the default policy — and keeps replies short and conversational, like a real text. Other risky actions (texting a different number, sending email, and so on) still follow the worker’s approval policy.

STOP and HELP are handled for you. If someone replies STOP (or UNSUBSCRIBE, CANCEL, END, QUIT) or HELP, the standard carrier opt-out / help reply is sent automatically and the worker is never woken — so it can’t text someone who opted out. START opts them back in.

If a text can’t be delivered — for example a landline, or a number that blocked messages — you’ll get a heads-up in your in-app notifications.

Enable Make a phone call in the worker’s Configure tab and a Phone calls panel appears. Search numbers (optionally by US area code), pick one, and claim it — the number becomes the worker’s own line for live calls. Release it anytime from the same panel and the monthly charge stops.

Natural, two-way calls. The worker talks in real time — it listens, responds, and can be interrupted just like a person. Turn Answer incoming calls on so people who dial the number reach the worker, and Allow outbound calls on so it can place calls itself toward a goal.

Tune the experience. Pick a voice, write an opening greeting, set how long a call may run, and add a number to warm-transfer to when a caller needs a human.

Recording is optional. Turn Record calls on to save call audio for later review — it’s off by default. When it’s on, add a recording-consent line and the worker reads it at the very start of the call. Check the consent laws where you operate first — many places require everyone on the call to agree.

Every call is logged. A Recent calls list in the same panel shows each call with its status, length, and outcome. Open one to read the full transcript, a short written summary the worker puts together after the call, the key points — and, when recording is on, play back the audio right there.

Voicemail is handled. On calls the worker places, if an answering machine or voicemail picks up, it recognizes that, marks the call as voicemail, and hangs up instead of talking to a machine.

Booking appointments. If you’ve enabled Run a connector action and connected a calendar, the worker can book an appointment during the call — it confirms the day, time, and who it’s for out loud, then adds it to your calendar right after you hang up.

After every call the worker automatically carries out any follow-ups it promised — a recap text, an email, a saved note, a calendar event — once the call ends. During the call it never sends those itself; it lines them up for afterward so nothing risky happens mid-conversation without your policy applying.

The calendar comes with the worker’s agent identity. One click on Give it an address in the Agent identity panel sets up its address, its calendar, and its contacts together — with nothing to connect or host.

It schedules with real people. The worker can look at what it's already booked for, check which times are genuinely free, then book a meeting and invite actual attendees. Everyone invited gets a normal calendar invitation they can accept or decline — the same as one a person sent. It can also reschedule, cancel, and reply to invitations people send it.

It checks before it books. Rather than guessing, the worker reads its own busy blocks first, so it offers times that are actually open instead of double-booking you.

Booking still asks you first. Looking at the calendar is free, but anything that emails a real person — booking, moving, cancelling, replying to an invitation — counts as a risky action, so under the default policy the worker asks for your approval first. Want it to look but never touch? Switch Let it change the calendar off and it can still answer "when am I free?" without being able to book anything.

It notices when something lands. When someone puts time on the worker's calendar, the worker wakes up, looks at what changed, and decides whether it needs to do anything — check for a conflict, reply to the invitation, or simply leave it alone.

Set the details. In the same panel you can change the name people see on invitations and set a default time zone for anything the worker books without naming one.

Not the same thing as Build a calendar page, which makes an interactive calendar you can open and share. That's a document; this is a real calendar.

A worker can diagnose itself. Ask it why something isn't working — or just ask it to do something on a channel that's broken — and instead of a dead-end "I can't", it runs a checkup across its channels (Telegram, email, texting, calls), connections, credits, and setup, then tells you the exact cause and the exact fix. For example: "your Telegram account is linked, but this worker isn't connected to your chat yet."

Some fixes it can run itself. A small, fixed set of safe repairs — connecting the worker to your already-linked Telegram chat, giving it its own address, or detaching a dead tool server — can be done by the worker on your say-so. Repairs count as risky actions, so under the default policy the worker always asks before running one. It can only ever fix its own settings: repairs can never change code, spend money, claim phone numbers, or touch anything outside this worker.

Fixes only you can do — like linking your Telegram account for the first time or claiming a text number — come back as step-by-step instructions with a link to the right screen. The same checkup lives in the worker's Configure tab as a Run checkup button, and if a channel that used to work breaks (say you pause your Telegram link), you get a one-time heads-up notification with the fix.

Workers learn from their runs. A failed run leaves the worker a short lesson it remembers next time, and when a worker keeps hitting the same wall, it drafts a set of operating notes from its recent failures. Nothing is applied automatically — the draft waits in the worker's Insights tab for your review, you apply or dismiss it with one click, and you can roll an applied note back afterwards.

Every worker opens inside Theo Chat with a Chat tab — a built-in conversation where you give it direction, ask it to do something, or just talk a goal through. Send a message and the worker gets to work in the background, then replies right in the thread.

When it needs your sign-off, an Approve / Reject card appears inline in the chat — approve and the worker picks up exactly where it paused. The in-app chat and a bound Telegram chat share the same ongoing conversation, so you can start a thread on your desktop and keep it going from your phone.

Replies and step-by-step progress appear live as the worker works — you’ll see a short note each time it finishes an action, then its full reply, without refreshing.

Attach files and projects. The + button in the composer lets you upload files (images, PDFs, docs, sheets) or add existing projects from My Projects — pick a presentation, note, flowchart, or whiteboard from a thumbnail gallery and the worker reads its content as context for that turn (up to three projects at a time). Attached projects are read-only reference — the worker won’t edit them.

Everything it says elsewhere shows up here. When a worker also talks on a channel — a Slack thread, a text message, an email — those conversations appear in this same feed as read-only thread cards: who asked, the steps it took, and what it replied, with an Open in Slack link on Slack threads. Filter pills (All · In-app · Slack) appear as soon as there is something to filter. The composer always talks to the worker here, in-app; the worker's header shows which Slack channel it listens in.

Naming. The name you give a worker stays yours. Click the name in the worker's header to rename it any time. If you'd rather have it re-label itself as your conversation shifts, turn on Auto-name from chat in Configure — it is off by default, and renaming the worker switches it off again.

Theo Claw lives right inside Theo Chat: open the Theo Claw tab in the chat sidebar to see your workers, pick one to open its chat, and switch between workers anytime from that same list. Its chat, configuration, runs, and insights all open right inside chat — switch back to your Theo Chat conversations any time from the same sidebar without losing them.

Give a worker a team of helpers and a single thread becomes a team chat — when it hands a sub-task to a teammate, that teammate’s reply shows up in the same conversation, labeled with its name.

Bind a worker to a Telegram chat and it becomes a teammate you can message. Send it instructions to kick off a run, get its replies delivered back to the chat, and answer its approval prompts right there with Approve / Reject buttons — no need to open the app. While it works you'll see a typing indicator, and when a run can't finish the worker tells you plainly what went wrong instead of going quiet.

The chat has memory. The worker remembers your ongoing Telegram conversation across runs and replies conversationally right in the chat, so a follow-up message picks up where you left off. Voice notes are transcribed, uploaded documents are read in as text, and photos you send are understood too — the worker looks at the picture and takes your caption with it, so you can talk to it the way you'd talk to a person.

Connect a worker without leaving Telegram. Send /agents to list your workers — each one that isn't connected yet comes with a Bind button — or use /bind <name> to connect one by name and /unbind to disconnect it. Binding a paused worker switches it back on so it's ready to work the moment you message it. You can also connect a chat from the worker's Configure tab in the app.

Operator commands. /pause and /resume stop and restart the worker, /reset (or /new) clears its memory of the current conversation so it starts clean, and /status <name> shows what a worker is up to — all without leaving Telegram. A paused worker never runs from a message; it replies that it's paused and points you at /resume.

A worker can live where your team already works. Connect your Slack workspace once, bind a worker to a channel, and anyone in that channel can @mention it — the worker runs in the background and replies in the thread. When it needs your sign-off, an Approve / Reject message with buttons lands in the same thread; approve and the worker picks up exactly where it paused. A finished run replies in the thread too, so nothing happens in silence.

1. Connect your workspace. From the Theo Claw hub's Channels section or a worker's Configure → Slack panel, choose Connect Slack and approve the install. One OpenCharts account owns a Slack workspace's connection; connecting again from the same account simply refreshes it.
2. Invite the app to the channel. In Slack, open the channel you want the worker in and type /invite to add the app. Private channels only appear in the picker once the app has been invited.
3. Bind a worker. In the worker's Configure → Slack panel, pick the channel and press Connect. Each worker listens in one channel; binding a paused worker switches it back on.
4. @mention it. The worker answers in a thread, remembers that thread across runs, and keeps each thread's conversation separate. A direct message to the app reaches your most recently connected worker.

It tells you it's on it. The moment you @mention it, the worker reacts with 👀 and posts one status message in the thread — “is on it…”. That same message then shows what it plans to do in its own words, each step as it finishes, and how long it has been going, so a longer job never looks stuck. When the work is done the status reads “Done” with the step count; when the answer was quick, the status message simply disappears and only the reply remains. The reaction flips to ✅ when done or ⏸ when it needs your approval, and an approval message spells out exactly what it wants to do (who it will email, the subject, the message) before you press Approve.

Once it's in a thread, just keep talking. After the worker has answered in a thread, replies in that thread reach it without another @mention. If your ask is ambiguous it asks one clarifying question and waits. It reads files you drop into the thread, and can upload real files back — a spreadsheet it built, a document it wrote. When it makes something in OpenCharts, it attaches an Open button; ask it to “share” or “send a link” and it publishes a link anyone can open without an account. A scheduled worker bound to a channel posts its report there on its own.

See it all back in OpenCharts. Every Slack conversation the worker holds shows up in its chat view in OpenCharts as a thread card — who asked, what it did, what it replied — with an Open in Slack link, and the worker's header shows the channel it listens in. You never have to switch apps to know what it has been up to.

It knows who is asking. The worker can tell whether the person mentioning it is you (its owner), a teammate with an OpenCharts account, or someone who isn't on OpenCharts yet — and it adjusts how it shares things (public links for people who can't open the editor). Runs are always billed to the account that connected the workspace, and the worker never reads another person's memories or data.

If Slack needs new permissions. When the app gains a capability (thread follow-ups, files, knowing who is asking), Slack only grants it on a fresh connection. The worker's Configure → Slack panel shows a Reconnect prompt when that's the case, and the worker's health check names the missing permission — reconnecting takes one click and keeps the channel binding.

Uninstalling the app from Slack disconnects the workspace; you can also disconnect a single worker from its channel at any time from Configure. Everything the worker does from Slack is recorded in its Runs tab like any other run.

Teams admins can set rules every worker linked to the organization follows on top of its own approval policy, from Teams → Settings → General → Theo Claw policy. Mark an action Always ask and it pauses for a human even on a worker set to run autonomously — including its replies in Slack. Mark it Never allow and it disappears from every org worker's toolset. One switch makes every action ask. Workers see the rules, so a pause reads as policy rather than a malfunction.

Want to know what a worker cost? Ask it — “what did this week cost?” — and it reports its own runs, outcomes, and credits for the window you name.

Every goal-driven worker is reachable over the OpenCharts API and MCP. Send it a message on a thread and poll for the reply, the things it made, or the approval it's waiting on; approve or reject that action over the API too; and read its usage. There is also an OpenAI-compatible endpoint, so any OpenAI SDK can talk to a worker by setting the model to agent:<id>. Details live in the developer docs.

Deploy turns a worker on so it responds to its trigger; Pause stops it without losing any configuration or history. Both live in the worker’s Theo Claw tab in Theo Chat.

The Runs tab lists every execution with its per-step status, duration, and any error, so you can see exactly what the worker did and when. The Insights tab rolls those runs up into a health snapshot — success rate, typical duration, and the most common failure reasons — so you can tell at a glance whether a worker is pulling its weight.

• Manual — you run it on demand from the workspace or by messaging it.
• Schedule — it runs on a recurring cadence you set.
• Event — it wakes up when something happens in your workspace.
• Telegram — a message to its bound chat starts a run.

Scheduled and event-driven runs happen in the background with the same step and time budget as a manual run, so a multi-step worker finishes instead of being cut off early.