Most automation platforms failed to create it.

With Zyk, one shot. Done.

https://youtu.be/nA3vTEUrOCo

It's not a skill issue. It's architecture.

Tools like n8n are built around a visual, stateless node graph. That works great for simple linear pipelines. But the moment you need durability, retries, timeouts, or human-in-the-loop interactions, you start fighting the tool instead of using it.

These aren't edge cases. They're the core of any real-world workflow:

• Durable execution: if a step fails halfway through, you need to resume, not restart from zero.

• Automatic retries: external APIs fail. Your workflow shouldn't.

• Timeouts: waiting for human input? You need a hard boundary, not an infinite hang.

• Human-in-the-loop: real automation often requires a human checkpoint before proceeding.

These are solvable. But only if the infrastructure underneath was designed for it from the start.

The stack that gets it right

We think the answer is Claude + Zyk + Hatchet.

• Claude understands plain English and converts it into executable workflow logic. No drag-and-drop, no node configuration.

• Hatchet provides the durable execution engine underneath. Retries, scheduling, timeouts, and human-in-the-loop baked in at the infrastructure level.

• Zyk ties it together. Describe what you want, get a working workflow.

The SWAPI demo in the video above isn't just a fun Star Wars example. It's a workflow with real complexity: external API calls, per-film interactive questions with a 1-minute timeout, and a final summary. The kind of thing that exposes the limits of most tools fast.

Zyk handled it in one shot.

Want to see the idea in action? zyk.dev — just a demo playground to demonstrate the core idea, not production-ready.

Zyk is open source and self-hostable: github.com/zyk-hq/zyk

https://youtu.be/fQX7MdDYKwc

Try it without credentials at Playground — prompt: "Fetch all Star Wars films from the SWAPI API, ask me if I like each George Lucas film, log my answers, and summarize all my decisions at the end."

Note: the playground is just to try the core idea. The real product runs as an MCP server inside Claude. You describe and manage workflows without ever leaving your AI assistant.

We're betting on two things: MCP-ready AI as the interface for building workflows, and durable execution as the engine for making them reliable. Zyk is what happens when you combine them.

You describe a workflow in plain English through Claude. Zyk generates TypeScript and deploys it to a durable execution engine. Retries, scheduling, and error handling built in by design. The generated code lives in your repo.

The insight: LLMs already know most APIs. The missing piece was always reliability. Modern durable execution engines solve that. Put them together and two-week visual editor projects become a one-line description.

A workflow can fire on a Slack message, create a GitHub issue, post Acknowledge/Escalate buttons back to Slack, and wait hours for a human to respond, then resume and close the loop automatically. No split endpoints, no manual state management.

Discuss on X:

https://x.com/i/status/2029912393447309674

GitHub: https://github.com/zyk-hq/zyk, not released yet, self-hostable.

I got far enough into it to see the problem. A YAML DSL is still a DSL. It still has limits. And the moment your workflow needs something the DSL does not support, you are back to fighting the tool. The format changed but the constraint did not.

The real problem with visual workflow development

Connecting a few services in a visual workflow tool takes two weeks. Not because the APIs do not exist. Not because connectors are missing. But because wiring services together visually is slow by nature. You map fields by hand. You debug expression languages. You trace why a value from step two is not arriving correctly in step four. You fight the tool when you should be solving the business problem.

The friction is not a missing feature. It is structural to how visual development works. And it compounds as workflows grow.

What the next generation looks like

Large language models have read the documentation for most APIs in the world. They understand authentication patterns, request shapes, error handling, and pagination. They can reason about how services connect to each other. And they can write the integration code in seconds, not days.

The missing piece was always reliability. Writing code is one thing. Making it retry on failure, resume after a crash, run on a schedule, and stay observable over time is another. That is now solved by modern durable execution engines that handle all of it without you building any of it.

Put these two things together and something shifts. You describe your workflow in plain language. The code gets written for you, real code you can read and version. It runs reliably underneath. And you never spend two weeks mapping fields in a visual editor again.

We believe the future of automation is conversational. And we believe current LLMs are already capable of writing workflows that are consistent, predictable, and production-ready. Not because they are magic, but because workflows are a narrow, well-defined problem. Give an LLM clear instructions, define the boundaries, and it produces reliable code. The scope is contained enough that this works today, not in some future version of the technology.

Where Zyk is going

The new version of Zyk is built on this idea. You describe your workflow to Claude in plain conversation. Claude writes it as real code, not a DSL, not a JSON config, actual TypeScript that you can read, version, and modify. A visual diagram updates live as the workflow takes shape so you always see what you are building. The workflow gets registered with a durable execution engine and runs reliably, with retries, scheduling, and monitoring built in.

No connector library to maintain. No drag-and-drop boxes. No vendor lock-in to a proprietary workflow language. Just a conversation, some generated code, and a reliable runtime underneath.

See it in action: Workflow automation without the drag-and-drop

An incident response workflow, described in plain conversation, deployed live, resolved with a single Slack button click.

This is a meaningful shift from what Zyk was. But it is not a retreat from the original goal. The goal was always to make serious workflow automation accessible to teams that should not need a dedicated workflow engineer to get things done. The first version took one step toward that. This version takes a bigger one.

Every workflow is automatically versioned in git in the background. You never touch a repository or write a commit message. But you get the full history of every change, the ability to roll back to any previous version just by asking, and a human-readable audit trail of everything that has ever run. The conversation is your interface. Git is your safety net. You never have to think about either.

This makes Claude your workflow designer and task manager in one. Not a visual editor with boxes and arrows. Not a terminal. Just a conversation where you describe what you need, watch it get built, and know it is running reliably underneath.

We are building it now. If you want to follow along or get early access, you know where to find us.

What does that look like in practice? Workflows. The processes that connect your systems and make things actually happen. Not the generic stuff you buy off the shelf but your crown jewels. The operations that make your business yours.

Platforms like Camunda, Pega, Appian and others exist to build exactly this. They have real strengths: reliable execution, proper governance and audit trails, consistent development patterns, and low-code accessibility. There's one gap though: these platforms weren't designed for how AI works today.

AI can do more than assist

Existing platforms have added AI-assisted modeling. You can ask an AI to help configure your BPMN diagram or suggest a form layout. But LLMs struggle with visual modeling languages. They weren't trained on millions of process diagrams with execution semantics. They're pattern-matching, and those patterns often need correction. Meanwhile, Claude Code can write a complete, working application from a natural language description. What if we designed a workflow format specifically for this? A structured, text-based spec that AI can generate reliably and humans can easily review? That's the opportunity we saw with Zyk.

The reality of who builds workflows

There's a vision of "citizen developers" building their own automations. It's appealing, and it works for simple use cases. But any workflow that handles money, customer data, compliance, or system integrations needs proper engineering discipline: testing, version control, code review, deployment pipelines, monitoring. The people building these workflows are developers, or at least very technical folks. They deserve tools that respect that.

Here's the nuance though: you still need visuals. Not for building, but for communicating. Business stakeholders need to see what's happening. Requirements discussions need a shared artifact. Documentation needs diagrams. The visual layer matters, just not as the primary authoring interface.

Introducing Zyk

Zyk is a workflow automation platform built on a simple premise: what if AI could write the workflow spec, and a battle-tested engine could run it? It's lightweight, extensible, and designed for how developers actually work.

1. Structured Natural Language → Executable Spec

Instead of dragging boxes around a canvas, you describe what you want in structured natural language. Think of it as a detailed prompt that captures your workflow requirements:

  Workflow: Incident Response                                                                                                                                     
                                                                                                                                                                  
  Triggers:                                                                                                                                                       
  - Manual trigger with form: title, severity (sev1/sev2/sev3), details                                                                                           
  - Webhook at /webhook/alert for monitoring systems                                                                                                              
                                                                                                                                                                  
  Integrations needed: GitHub, Slack                                                                                                                              
                                                                                                                                                                  
  Config:                                                                                                                                                         
  - github_repo: from environment                                                                                                                                 
  - oncall_user: Slack user ID from environment                                                                                                                   
  - escalation_user: Slack user ID from environment                                                                                                               
  - acknowledge_timeout: 15 minutes                                                                                                                               
  - status_update_interval: 30 minutes                                                                                                                            
                                                                                                                                                                  
  Flow:                                                                                                                                                           
  1. Create GitHub issue with incident label and severity label                                                                                                   
  2. Create Slack channel incident-{issue_number}, invite on-call user                                                                                            
  3. Post incident summary with link to GitHub issue                                                                                                              
  4. Human task: Page on-call with options [Acknowledge, Escalate, False Alarm], timeout 15min → auto-escalate                                                    
  5. If False Alarm → close issue, archive channel, END                                                                                                           
  6. If Acknowledged → post confirmation, update GitHub issue                                                                                                     
  7. Human task: Confirm severity [SEV1, SEV2, SEV3]                                                                                                              
  8. If SEV1 → notify #leadership and #engineering (parallel), mention deploy freeze                                                                              
  9. Loop until resolved:                                                                                                                                         
    - Wait 30 minutes                                                                                                                                             
    - Human task: [Post Update, Mark Resolved]                                                                                                                    
    - If update → add comment to GitHub issue                                                                                                                     
    - If resolved → collect root cause + resolution, exit loop                                                                                                    
  10. Close GitHub issue with resolution details                                                                                                                  
  11. Post resolution summary to channel                                                                                                                          
  12. If SEV1/SEV2 → wait 48h, create post-mortem issue, archive channel                                                                                          
  13. If SEV3 → archive channel immediately                                                                                                                       
                                                                                                                                                                  
  Error handling:                                                                                                                                                 
  - Retry integrations 3x with exponential backoff                                                                                                                
  - Continue if notification channels don't exist

From this description, AI generates a complete YAML specification, the source of truth for your workflow. But you're not limited to staring at raw YAML. The designer can show a visual representation alongside it: the YAML on one side, a clear diagram of the flow on the other. You get the best of both worlds: a text-based format that's version-controllable and AI-friendly, plus a visual layer for understanding and communicating the flow.

2. The YAML Spec: What Gets Executed

From your description, Zyk generates a YAML specification. Without getting too deep into the syntax, here's what it captures: workflow metadata (name, version, ownership), triggers (webhook, schedule, manual start, or external event), steps (each with an ID, type, configuration, dependencies, and conditions), human tasks (assignee, available actions, timeout behavior), and error handling (retries, fallbacks, compensation). The script type lets you run custom code for data transformation, and external workers let you delegate steps to your own async services. The key insight: this YAML is both human-readable AND machine-executable. Business analysts can review the visual diagram. Engineers can version control the YAML. And the engine runs it exactly as defined.

3. Deterministic Execution

The spec isn't just documentation, it actually runs. Under the hood, Zyk uses Temporal, a proven workflow engine trusted by companies like Netflix, Stripe, and Snap. That means reliable execution with automatic retries and timeouts, durability that survives crashes and restarts, full observability with execution history and replay, and scalability to handle millions of concurrent workflows. Enterprise-grade reliability without enterprise-grade complexity.

4. Human-in-the-Loop

Workflows often need human input: approvals, decisions, acknowledgments. Zyk includes a dedicated Tasklist where users can see and act on pending tasks. But people live in Slack (or Teams, or wherever), so for our MVP we're using Slack as the primary human interface. The assigned person gets a message with action buttons. They click. The workflow continues. No context switching. The workflow spec simply defines what message to show, who should see it, what buttons to display, and what happens for each choice. The engine handles the rest.

Why This Approach?

AI-Native by Design: LLMs are really good at generating structured specifications from natural language. Give them a clear description and they produce consistent, executable output. No proprietary visual language to hallucinate. And when the AI makes a mistake? The spec is readable. You can fix it yourself in seconds, or refine your prompt and regenerate.

Version Control Friendly: Your workflows are text files. That means Git history, pull requests, code review, diff and merge, branching strategies. All the things developers expect. All the things visual diagrams make painful.

Who Is This For?

Zyk is for developers and technical teams who need reliable workflow automation without the enterprise overhead. You might be a startup that needs incident response, onboarding flows, or approval processes. A dev team tired of maintaining brittle scripts. An SMB that can't afford (or doesn't need) a full BPM suite. Anyone who's thought "I wish I could just describe this workflow and have it work."

If you want a visual canvas to drag-and-drop boxes, this isn't for you. Plenty of tools do that well. If you want to write (or have AI write) a clear spec and have it execute reliably, keep reading.

P.S. Yes, "Zyk" is a weird name. We just came up with it. But picture a cute little creature that's intelligent, lightning fast, and reliable, the kind that never lets you down. That's Zyk.