Forem: Frederic Zhou

AI Products Are Not About Chat — They Are About Lowering Development Barriers

Frederic Zhou — Fri, 19 Sep 2025 04:51:54 +0000

When most people think of “AI products,” they imagine chatbots.
But that’s just a demo — the “Bitcoin” of AI, not the whole blockchain.

The real power of AI in product development is not to talk with users for fun, but to make it dramatically easier to build products that solve real business problems.

⸻

Traditional Development vs. AI-Driven Development

In traditional software development, the process looks like this:

Collect user requirements.
Product managers design workflows.
Engineers write code to cover every scenario.
Deploy, wait for feedback, iterate.

⠀
This works — but it’s slow, rigid, and expensive.
If you miss an edge case, users are stuck until the next release.

AI changes this model.

Now, instead of hardcoding every decision path, we can:

Accept natural language input (any format).
Let an AI agent parse intent and dynamically pick tools or actions.
Generate an output immediately — even if it’s the first time the user ever asked for that scenario.

⠀
This turns our product into a system that adapts in real time, rather than a frozen set of predefined flows.

⸻

AI Is for Developers, Not Just Users

Here’s the key insight:
AI does not directly “solve” user problems — it solves developer problems.

It lets small teams build systems that used to require massive engineering resources.
It lets us cover more edge cases with fewer hardcoded rules.
It lets us delay decisions, experiment faster, and ship prototypes that actually work in the wild.

For users, this feels like “magic.”
For teams, it’s simply better leverage.

⸻

The Real Value: Business Logic + Flexibility

Users still care about the same things:

Did my task get done?
Was it fast and affordable?
Was the experience smooth?

⠀
AI doesn’t replace good product thinking — it enhances it.
The team still needs deep understanding of business logic, customer workflows, and what “success” means.
But now, instead of spending months coding every possibility, we can let AI handle the messy details, reason about ambiguous input, and keep the product running smoothly.

⸻

Bottom Line

AI products are not “chat windows.”
They are adaptive systems where input → reasoning → action → output forms a live loop, often with human approval steps in between.

Think of AI as the brain inside your product — not the interface.
It’s there to make your workflows dynamic, your edge cases covered, and your product faster to build and easier to maintain.

The best AI products will not feel like “AI products.”
They will just feel like software that finally understands what you wanted.

Implement a Traceable ReAct Agent Using Temporal and LangChain

Frederic Zhou — Tue, 16 Sep 2025 07:26:15 +0000

While there are existing examples of workflows invoking AI agents, most of those workflows merely call the agent as a whole—tool invocation happens outside the workflow. As a result, it’s impossible to observe when the LLM chooses to call a tool, and any issues—like errors or delays in the tool—aren’t visible in the execution trace. In contrast, our approach embeds the tool calls inside the Temporal Workflow itself.** This way, each tool invocation becomes part of the workflow history, fully traceable and observable—including tool failures or latency**.

This integration not only surfaces the full reasoning chain of the agent but also leverages Temporal’s built-in observability for debugging and reliability.

Project repo: https://github.com/Frederic-Zhou/temporal_agent_workflow

How to build Temporal + Langchain ReAct AI Agent
This article will walk you through building an observable, extensible AI Agent system based on Temporal and Langchain. We’ll use a ReAct Agent for automatic reasoning and tool invocation, and every step can be traced in the Temporal workflow. Hope you enjoy the hands-on process—feel free to reach out and share your ideas!

1. Environment Setup

Start Temporal Server (docker-compose is recommended, just a few minutes)
Install dependencies (managed by poetry, just run poetry install)
Set up your API KEY (if you want to use external LLMs like Gemini)

2. Design the Agent Workflow

The core logic is in workflows.py, where we use a Temporal workflow to orchestrate LLM reasoning and tool calls:

@workflow.defn
class AiAgentWorkflow:
    @workflow.run
    async def run(self, query: str) -> str:
        messages = [HumanMessage(query)]
        MAX_STEPS = 8
        for _ in range(MAX_STEPS):
            ai_msg = await workflow.execute_activity(
                "llm_chat",
                messages,
                schedule_to_close_timeout=timedelta(seconds=60),
            )
            messages.append(AIMessage(**ai_msg))
            if ai_msg["tool_calls"]:
                for tool_call in ai_msg["tool_calls"]:
                    tool_call_result = await workflow.execute_activity(
                        tool_call["name"],
                        tool_call["args"]["params"],
                        schedule_to_close_timeout=timedelta(seconds=10),
                    )
                    messages.append(
                        ToolMessage(
                            content=str(tool_call_result),
                            tool_call_id=tool_call["id"],
                        )
                    )
            else:
                return messages[-1].content

3. Implement Tools and LLM Calls

Define your LLM and tool logic in activities.py:

@activity.defn
async def llm_chat(messages: list) -> str:
    llm = init_chat_model("gemini-2.0-flash", model_provider="google_genai")
    llm_with_tools = llm.bind_tools([add, division])
    response = llm_with_tools.invoke(messages)
    return response

@activity.defn
async def add(params: list[int]) -> int:
    return sum(params)

class divisionParams(BaseModel):
    a: int = Field(..., description="Numerator")
    b: int = Field(..., description="Denominator, must not be zero", gt=0)

@activity.defn
async def division(params: divisionParams) -> int:
    return params.a // params.b

You can add more tools as you need—just implement an activity and register it with the worker.

4. Start the Worker

worker.py registers and runs all workflows and activities. You usually don't need to change much here:

async def main():
    client = await Client.connect("localhost:7233")
    worker = Worker(
        client,
        task_queue="my-task-queue",
        workflows=[AiAgentWorkflow],
        activities=[llm_chat, add, division],
    )
    print("Worker started.")
    await worker.run()

5. Start a Workflow (Submit a Task)

Use starter.py to submit an Agent reasoning task and see the full process in action:

async def main():
    client = await Client.connect("localhost:7233")
    result = await client.execute_workflow(
        "AiAgentWorkflow",
        "what is 1 divided by 2 then add 1?",
        id=f"AI-Agent-workflow-{{uuid.uuid4()}}",
        task_queue="my-task-queue",
    )
    print("Workflow result:", result)

6. Observability & Debugging

With the Temporal UI (default http://localhost:8233), you can see every LLM reasoning and tool call's input, output, duration, and status in real time. Debugging and tracing are super convenient.

7. Extensions & Advanced Usage

Add any tool you want—just implement a new activity and register it with the worker.
Integrate more LLMs or external APIs.
Use this project as a template to quickly build your own observable AI Agent system.

8. Reference & Community

Full code and more details: https://github.com/Frederic-Zhou/temporal_agent_workflow

If you have any questions, ideas, or just want to chat, feel free to reach out! You can also open an issue on GitHub or join the Temporal community.

Workflows: Windmill vs n8n vs Langflow vs Temporal — Choosing the Right Tool for the Job

Frederic Zhou — Tue, 16 Sep 2025 07:21:18 +0000

Over the past year, I’ve been working with four very different (and very opinionated) workflow tools: Windmill, n8n, Langflow, and Temporal.

Each has its own sweet spot, its quirks, and its “oh-no-why-did-I-choose-this” moments.

This post is my field guide to these four tools — what they do best, where they fall short, and how I mix them together into a pragmatic, production-ready workflow stack.

1. Meet the Four Players

Before we dive into comparisons, let’s introduce the cast.

🛠 Windmill — The Script Wizard

Windmill is your best friend when you want to glue things together quickly. It lets you write scripts in Python, TypeScript, Go, and even build small internal apps and expose them as APIs. It’s ridiculously easy to chain functions together, build internal tooling, and deploy lightweight automations.

But here’s the thing: Windmill is not built for high concurrency.

Every script spins up an isolated runtime (256 MB or more), which is great for safety but heavy for high-QPS scenarios. Think of Windmill as the artisan chef who makes each dish by hand — delicious, but not ideal when you need to serve 10,000 burgers in an hour.

🔗 n8n — The Connector

n8n is like Zapier on steroids, but self-hosted and much more flexible.

It excels at connecting external services: Slack, Stripe, Notion, databases, webhooks, timers — you name it. Its visual interface makes it easy to read, easy to share, and easy to debug.

But as workflows grow, visual sprawl sets in.

A dozen branches, nested loops, error handling — suddenly your “visual workflow” looks like a spaghetti diagram from a conspiracy movie. Long-running human-in-the-loop flows can also feel clunky. And yes, it now has AI Agent nodes, but if you compare them with a specialized AI orchestration platform like Langflow, they feel a bit… basic.

🧠 Langflow — The AI Orchestrator

If you do AI-driven workflows, Langflow feels like cheating.

It’s basically a visual LangChain: drag-and-drop LLMs, tools, vector stores, retrievers, memory components, and chain them in powerful ways. You can experiment with prompts, watch reasoning steps in real-time, and rapidly iterate.

But Langflow is laser-focused on AI use cases.

If you need to connect to SaaS APIs, schedule jobs, handle retries, or do database polling, you’ll likely wrap Langflow in something else (like n8n) to handle those responsibilities. It’s an AI brain, not a whole nervous system.

🏗 Temporal — The Heavyweight

Temporal is the “serious” one in the room. It’s code-driven, production-grade, distributed workflow orchestration.

It shines when you need strong consistency, retries, fault tolerance, long-running workflows, and high concurrency. Payments, order pipelines, state machines, human approvals — Temporal is designed to never lose state, even if your entire cluster crashes.

But be warned: Temporal is code-first.

There’s no pretty drag-and-drop interface. You’ll be writing workflow code, activity code, and deploying workers. It’s the most powerful of the bunch, but with great power comes a steeper learning curve.

2. Head-to-Head Comparison

Let’s put them side by side on the dimensions that actually matter.

3. When I Pick Each Tool

Here’s my decision matrix when I start a project:

Windmill — internal glue logic, small automations, ad-hoc jobs, one-off scripts, quick web endpoints.
n8n — external API integration, webhooks, cron jobs, notifications, “business glue”.
Langflow — LLM agents, retrieval-augmented generation (RAG), multi-step AI reasoning.
Temporal — critical backend processes that must be durable, auditable, recoverable, and scale under load.

In practice, I rarely use just one. Instead, I mix them:

Webhook → n8n flow (validate + route)
→ If AI decision needed → Langflow Agent
→ If long-running workflow → Temporal Workflow
→ For quick side tasks → Windmill script

4. The Reality Check

A few subtle but important clarifications:

Windmill is powerful, but don’t expect it to behave like a serverless clusterless Lambda farm. If you need to process 50k events/minute, you will need aggressive tuning and parallel workers — or just pick a different engine.

n8n’s visual workflows can stay maintainable if you use sub-workflows and templates — treat them like code modules.
Langflow is not a replacement for full workflow orchestration — it’s your AI layer. Pair it with n8n or Temporal for a complete solution.

Temporal is not free magic. You still need to think about idempotency, schema evolution, monitoring, and versioning. But it pays off massively for business-critical processes.

Final Thoughts No single tool is “the best” — they’re like different instruments in an orchestra.

Windmill is the agile soloist for small, precise pieces.
n8n is the versatile connector, playing well with others.
Langflow is the AI virtuoso, brilliant at reasoning.
Temporal is the percussion section — steady, reliable, unflinching under pressure.

When you use them together, you can build a workflow system that’s robust, scalable, easy to iterate, and fun to work with.

TL;DR for Busy Engineers

Windmill → Best for low-frequency scripts + internal tools
n8n → Best for external integrations + readable flows
Langflow → Best for AI agents + RAG pipelines
Temporal → Best for high-concurrency, long-running, reliable workflows
Mix and match them like Lego bricks, and you’ve got yourself a solid workflow stack.