Build your 
workflow with Tevyr AI.
Automate the whole show in minutes.
Connect to your favorite tools. Lights, sound, cameras, Slack, AI copy, scheduled emails, downstream automations — all choreographed in a visual flow builder, fired from a hotkey, a session lifecycle, a cron, or a Stream Deck button. Build once. Fire forever.
Describe the show, not the steps.
AI builds the macro. You run it.
Natural language to a working macro. Type 'on session start, post to Slack and flash the timer red at 1 minute remaining' and Tevyr AI generates a 3-step macro wired to your integrations. Don't like the screen target? Type 'move the timer flash to staff only' and Tevyr AI mutates only that step — preserving your retry, on-error, and trigger config. The violet ring shows what changed; you've never touched code.
AI macro guideLess rehearsal. More show.
Stop memorizing action verbs and digging through docs. Describe the cue in plain English — Tevyr AI builds the macro, wires the integrations, and gets out of your way. When the run-of-show changes at T-minus-5, you don't rebuild. You type the change and ship it. The same AI powers your macros, your rundowns, and your refines — one tool, one mental model, one bill.
See AI macros guideNo verbs to memorize.
Describe what should happen in plain English — or drop in a workflow spec or requirements doc (PDF, DOCX, CSV). Tevyr AI extracts the steps, maps them to the right action verbs — Slack, timer, polling, sessions, displays — and wires the triggers.
Change one thing.
Type the change in the refine bar — reference the step by name, position, or just describe what should change. "Swap the Slack channel to #staff", "add a 5-second wait after Slack", "change step 2 to staff only." Tevyr AI mutates the targeted step — retries, error policy, and the rest of the chain stay intact.
It knows your room.
Tevyr AI sees your sessions, polls, ad-hoc timers, integrations, sponsor walls, and webhooks before it generates. No hallucinated session IDs, no fake Slack channels, no orphaned webhooks — just the macro you asked for, ready to run.
5 integrationsStop being the orchestration layer.
Let the workflow be.
Right now, you're tab-switching between Slack, vMix, lights, and the IFB — live, with no take-backs. Miss one step and the room sees it. Macros run the cue. You run the show.
See the macros guideThe workflow holds the sequence.
Cue stacks live in the macro. Version-controlled. Dry-run before doors open.
Press the button. Run the room.
Hotkey, Stream Deck, lifecycle, or schedule. Every step fires in parallel.
What happened. Not what people remember.
Every fire writes itself down. The next rehearsal starts from a record.
Auto-heal the workflow.
Reliability, your way.
Every step auto-heals — auto-retries with configurable backoff, plus an on_error policy you set: continue, abort, or retry. Failures stay scoped. Workflows recover before the audience notices. Broken integrations don't break the show.
Auto-heal + retriesRecovery isn't optional. The policy is.
Every step ships with auto-retry. You set the count, the backoff curve, and the on_error policy that fits the moment. The cue stack adapts to your show — not the other way around.
Retry + on_error guideFire it however the show fires.
Manual, hotkey (⌘-key), session lifecycle (start / end / pause / resume / warning / overtime), and cron + IANA schedule — all bind to the same macro. Same stack, every entry point.
Your error policy. Per step.
Slack post fails? Set on_error: continue — the cue keeps moving. vMix scene cut fails? Set on_error: abort — the show doesn't advance with the wrong scene live. Each step decides on its own.
See which steps actually work.
Each step shows a live success rate from the last N runs. Resend at 80%? You know to add retries or fix the integration before it breaks the show.
One macro, the right view on every screen.
Speaker monitor runs the script and countdown. Audience screen shows a brand-themed timer with sponsor wall behind it. Staff display shows the agenda, IFB cues, and producer notes the audience never sees. Greenroom holds time-of-day. Embed iframes for any in-house dashboard. One macro fires — every output renders the view its role needs.
Cue the producer without saying a word.
Wire a Generic HTTP connection to your IFB system's HTTP endpoint. Fire a "5 minutes" cue straight to the speaker's earpiece from the same macro that flashes the on-stage confidence monitor.
Your show isn't linear.
Your automation shouldn't be either.
Linear chains can't run a live show. Macros support parallel branches that fire concurrently, conditional routes that choose by context, waits that hold for a real-world signal, and sub-macros that compose without bound — every shape a production actually needs.
Workflow shapes deep-diveProduction stacks reuse. They don't re-author.
Build SPONSOR DELIVERY LEDGER once, call it from every show. Pair flow.branch_if with {{ctx.session.is_bilingual}} so the Spanish-service variant fires the right teleprompter cue. Use flow.wait_for_event to pause the macro on a session lifecycle signal instead of guessing a duration. The shapes compose.
See the 3 production recipesChain sub-macros without bound.
Real-time updates, versioned saves, fault-tolerant by design. When a single macro outgrows the caps, split the long-running half into a sub-macro and let the parent fire-and-forget.
Every run carries the room with it.
Drop {{session.name}}, {{round.number}}, or any prior-step output into any URL, header, or body. The macro fires with the moment's live data — never a stale template.
Trigger Tevyr from anywhere. Fire anywhere from Tevyr.
Inbound: Bitfocus Companion, vMix, OBS, Slack slash commands, your own webhooks — anything that speaks HTTP can run a macro. Outbound: every step can hit Slack, Discord, Notion, Resend, your own API, or any URL. The room talks both ways.
Recurring shows. Zero recurring work.
Run every Sunday at 9:55am forever.
Every recurring cue you fire by hand is time you're not getting back. Tevyr moves the recurring spine — Slack digests, ChatGPT briefings, Zapier syncs, any HTTP webhook — to a server-side scheduler that fires on time, every time, whether you remember or not.
Schedules guideThe hidden hours in every recurring show.
Sunday service at 9:55. Monday huddle at 9:00. The nightly ChatGPT briefing. The hourly Slack digest. Each one is a calendar reminder, a phone alarm, a 'did I remember?' moment — and a five-minute panic the week your operator is out sick. Tevyr moves the recurring spine to a server-side scheduler, so the cue fires whether you're there or not, the room is open or not, anyone remembers or not.
Cross-macro schedulingScheduled Across Every Timezone.
IANA-aware schedules fire in the event's local time — DST-safe, region-correct, from any operator anywhere.
Hours Back. Every Week.
A single recurring schedule replaces dozens of phone alarms, calendar reminders, and "did I remember?" moments — every week, forever.
Your favorite tools.
Already wired up.
11 saved-connection templates in the Integrations Library. OAuth into Slack, paste a Notion token, drop a Discord webhook URL, store an API key for OpenAI / Anthropic / Resend, expose your LAN vMix / WLED through a tunnel, or fall back to Generic HTTP for anything else. Credentials encrypted at rest, OAuth tokens auto-refresh.
Browse the integration librarySet up once. Reference everywhere.
Save a connection in Settings → Integrations, then call it from any macro via flow.http_request. The same Slack connection drives the producer alert in your conference macro and the visitor welcome in your worship macro. Edit the connection once; every macro updates.
Macros + integrations recipesThe auth model each tool actually ships
OAuth gives you an auto-refreshing access token — sign in once, the refresh runs on a background timer so the connection never goes stale. API key lets you paste a personal access token or secret and we store it encrypted at rest with AES-256-GCM. Webhook URL accepts a signed inbound payload — paste the URL, fire from any macro. Tevyr handles the refresh, the rotation, and the encryption — no proprietary middleware sits between you and the tool.
Every run logged. Every response captured.
Each run stores the full response of every step — body, status, headers, timing. Open the Playback panel, click a step, and see the actual payload your endpoint returned. Days later, for audit, debugging, or compliance — the run history is right there.
{
"body": { "ok": true, "channel": "C0L4N0M" },
"status": 200,
"headers": {
"content-type": "application/json; charset=utf-8",
"x-slack-req-id": "a4f9c2e1b8",
"date": "Wed, 20 May 2026 16:39:50 GMT"
},
"durationMs": 137
}{{ctx.*}} resolves at fire time
URL, headers, JSON body, and form fields all support {{ctx.session.name}}, {{ctx.timer.remaining}}, {{ctx.now.local}} and a dozen more. The same macro fires personalized copy for Round 1 and Round 5 — no per-round duplicates.
When a cue misfires —
the show doesn't.
Retry, Resolve, and Stop live on the operator's screen — never the audience's. Every fire goes on the record for 90 days: who triggered it, which step ran, the exact payload, the retry chain. The same macro fires from a Bitfocus Companion button the producer already owns — with skip_if_running protecting the round-bell from a double-press.
Live recovery + audit guideOperator-only recovery. Stakeholder-grade receipts.
The Live Playback panel hides nothing from the operator and shows nothing to the audience. The History tab keeps 90 days of full-payload receipts — exportable when a sponsor asks if their cue actually fired, when a client wants the post-show timing report, when last Saturday's bug needs answering Sunday at 9. And every macro has a stable /v1/macros/run/<id> URL — the same $200 Stream Deck the producer already owns becomes a $5k cue console, with skip_if_running on by default so a button-mash never doubles a cue.
Public /v1/ API · macrosThe audience never knows a cue misfired.
When auto-heal is off — by your choice, on the steps where you want a human in the loop — Retry, Resolve, and Stop live on the operator's screen, not the audience's. Step 3 fails? Retry picks up at step 3 with the prior-step output still in context. The show keeps moving. The audience never sees the seam. Stop kills a mid-flight runaway on the next tick.
Prove every cue fired. Every sponsor played.
Every fire on the record for 90 days — who triggered it, which step ran, the exact payload, the retry chain. Pull the receipt when a sponsor asks if their slot played, when a client wants the timing report, when last Saturday's botched cue needs answering Sunday at 9.
Your $200 Stream Deck just became a $5k cue console.
Each macro has a stable /v1/macros/run/<id> URL. Drop into the Companion button the producer already owns, the vMix shortcut the switcher already maps, the OBS hotkey the streamer already presses. skip_if_running is on by default — a button-mash never double-fires the round bell.
Transform your day with macros you can rely on.
Build once. Fire forever. Macros ship on every plan; saved integrations scale from 5 to unlimited as you grow.