DEV Community: Hanna Chaikovska

We’re building a SaaS AI assistant in ~90 lines of TypeScript (Live)

Hanna Chaikovska — Thu, 26 Mar 2026 00:31:37 +0000

Most AI assistant demos look impressive until you try to actually ship them inside a product. That’s where things usually break. Not because of the model, but because of the infrastructure around it: managing state across steps, handling tool calls, and dealing with retries.

The "Demo-to-Production" Gap
After experimenting with different approaches, we kept running into the same problem: systems were either too abstract and hard to control, or too manual and impossible to scale. We decided to try something different - keeping everything in code. No visual builders, no hidden layers. Just a TypeScript-based workflow that defines how the assistant behaves.

Why Code-First over No-Code?
Surprisingly, this made things much simpler. Instead of "prompt engineering," it started to feel more like actual software engineering:

Explicit state: No more guessing what the agent remembers.

Predictable execution: You control the flow, not a black-box framework.

Easier debugging: Standard logs and traces instead of visual spaghetti.

We ended up with a pattern where a functional in-product assistant is implemented in around 90 lines of code. This isn't a toy example; it's a blueprint for something you’d actually embed in a B2B SaaS.

Join our Live Build session
If you're working on AI features or trying to move your agents from demo to production, we're running a live session to walk through this process step-by-step. We'll cover:

Defining assistant behavior directly in TypeScript.

Handling tool-calling and multi-step flows without the mess.

Real-time observability and debugging.

Curious to hear how others here are approaching agentic infrastructure. Are you sticking with frameworks, or building custom runtimes?

The "Chat Window" is the new Loading Spinner

Hanna Chaikovska — Fri, 13 Mar 2026 13:21:55 +0000

In 2026, we’ve reached a point where "Chatting" with AI is often just a fancy way of waiting for things to happen.

Most AI implementations are still stuck in a fragile request-response loop. But for real-world SaaS, the value isn't in the chat; it's in autonomous workflows that run in the background while the user is away.

The problem? Building these "invisible" agents is technically terrifying. If a background task takes 10 minutes and your server blinks, the task is gone. You lose context, waste tokens, and leave your database in an inconsistent state.

The Shift Toward Durable Execution
We shouldn't be writing manual retry logic or complex DB checkpoints for every AI feature. We should be focusing on Resilient AI.

We recently launched Calljmp (and became Product of the Week on DevHunt because of this), but the rank isn't the point. What matters is the shift toward Durable Execution. Your agent shouldn't "die" on a network hiccup—it should simply "pause" and resume exactly where it left off.

Here is how a resilient, background agent looks in practice using Calljmp. Even if the server restarts between these two steps, the process stays alive:

Why this matters
The era of "toy" AI wrappers is over. To build real products, we need infrastructure that handles the "boring" stuff (state management, recovery, security) automatically.

Persistence by default: No more manual Redis checkpointing.

Cost Efficiency: Don't pay twice for the same LLM call if the connection drops.

Observable Logic: See exactly where your agent is in the workflow.

What’s your biggest hurdle in moving AI from a simple chat to a background process? Is it the infrastructure, the cost, or the reliability? Let’s discuss.

Build your first resilient agent at calljmp.com

Launch: Calljmp — TypeScript agentic backend for real AI workflows

Hanna Chaikovska — Wed, 25 Feb 2026 17:01:54 +0000

Today we launched Calljmp on DevHunt — a platform for developers to build, run, and ship real world AI agents as TypeScript code.

Calljmp provides state, retries, observability, cost tracking and HITL workflows so your AI agents behave like backend systems — not magic black boxes.

Check it out and share feedback: https://devhunt.org/tool/calljmp

Best Alternatives to Mastra AI and Why Calljmp Stands Out

Hanna Chaikovska — Wed, 18 Feb 2026 23:23:16 +0000

AI agent frameworks have made it much easier to start building LLM-powered workflows. TypeScript-first tools like Mastra AI give engineers structure, typing, and a cleaner way to define agents compared to early script-based approaches.

But once teams move from prototypes to production systems, many discover the same thing: frameworks alone do not solve the hardest problems.

This article looks at the best alternatives to Mastra AI and explains in detail why Calljmp is often the strongest choice when building real, long-running, production-grade AI workflows.

What Mastra AI Does Well

Mastra AI is designed to improve developer experience. It focuses on TypeScript, explicit workflow definitions, and clean abstractions around prompts and tools.

It works well for:

Prototyping agent logic

Local experimentation

Early-stage internal tools

Teams that want structure without much upfront complexity

For many teams, Mastra is a solid starting point. The limitations appear when execution becomes long-lived, stateful, and failure-prone.

Where Mastra and Similar Frameworks Fall Short
Execution State Is Not Durable

Mastra helps you describe what an agent should do, but it does not persist execution state by default. If a process crashes or a server restarts, the workflow has no built-in way to resume safely.

To fix this, teams must build:

Custom state persistence

Checkpointing logic

Recovery and reconciliation flows

This quickly turns into infrastructure work rather than application logic.

Long-Running Workflows Are Fragile

Real-world AI agents rarely finish in one request. They wait for external APIs, webhooks, or human approvals. These workflows can last minutes, hours, or even days.

Frameworks assume short-lived execution. Orchestration, retries, and safe continuation are left to queues, cron jobs, or custom glue code.

Observability Requires Manual Work

When something goes wrong in production, teams need to know exactly what happened.

With frameworks like Mastra, observability usually means manually wiring logs, traces, metrics, and cost tracking using third-party tools. This often leads to partial visibility and missing context.

Infrastructure Complexity Grows Quickly

Once systems reach production, teams end up owning:

Retry and idempotency logic

Pause and resume coordination

Error escalation paths

Monitoring and alerting

Human-in-the-loop mechanics

At this stage, the framework is no longer lightweight. It becomes the foundation of a system that was never designed to be a runtime.

What Teams Look for After Mastra

After hitting these issues, teams typically want:

Durable execution that survives crashes and restarts

Safe retries without duplicated side effects

Native pause and resume for human input

Full observability without custom setup

TypeScript-first development without heavy infrastructure

Some teams adopt general workflow engines like Temporal or Step Functions. These solve orchestration but introduce steep learning curves and significant operational overhead.

What many teams actually need is a runtime purpose-built for AI agents.

Calljmp as a Production-Ready Alternative

Calljmp takes a fundamentally different approach. It is not just a framework for writing agent logic. It is a runtime designed to run agentic workflows safely over time.

Instead of assuming execution is short and reliable, Calljmp assumes:

workflows will pause

processes will crash

retries will happen

humans will be involved

Because of that, it provides durable execution as a core primitive rather than an add-on.

Why Calljmp Is the Strongest Alternative to Mastra AI
Durable Execution by Default

In Calljmp, every step of a workflow is checkpointed automatically. Execution state persists across restarts, crashes, and long waits.

This is critical for:

human-in-the-loop systems

webhook-driven flows

multi-step backend orchestration

Teams do not need to build their own state machines or recovery logic.

Built-In Observability

Calljmp includes observability out of the box:

full execution timelines

inputs and outputs for each model and tool call

latency and cost tracking

detailed error context

There is no need to manually wire logging or monitoring just to understand what an agent did.

Safe Retries and Resilience

Retries are one of the hardest parts of stateful systems. Calljmp encodes retry safety directly into the runtime, preventing duplicated work and inconsistent side effects.

This is especially important for workflows that interact with external systems.

Native Pause and Resume

Human approval flows are easy to describe but hard to implement correctly.

With Calljmp, workflows can pause and resume days later without Redis queues, custom workers, or manual reconciliation. The runtime is designed with this execution model in mind.

Security and Control

Calljmp treats execution as a managed environment with scoped permissions, auditability, and traceability. These are requirements for production systems that frameworks typically leave to the application layer.

Seeing the Difference in Practice

A detailed feature comparison between LangChain, Mastra, and Calljmp is available in this breakdown of frameworks versus runtimes.

If you want to see what a production-grade AI runtime looks like in action, this walkthrough shows Calljmp running a real workflow step by step.

Final Thoughts

Mastra AI and similar frameworks are an important step forward. They bring structure and clarity to agent development.

But structure alone does not guarantee reliability.

When AI systems become long-running, stateful, and business-critical, execution guarantees matter more than abstractions. That is where a runtime approach becomes essential.

For teams moving beyond prototypes and into production, Calljmp represents a natural evolution and one of the strongest alternatives available today.

Architecting Durable AI Agents: Solving the Volatile State Problem

Hanna Chaikovska — Wed, 11 Feb 2026 15:04:38 +0000

The industry is moving from "Chatbots" to "Autonomous Agents," but our infrastructure is still stuck in the stateless request-response paradigm. If you are building long-running agents (5+ minutes execution time), you cannot rely on standard Node.js/Python memory to hold your reasoning chain.

The Architecture Flaw: Memory-Based Steppers
Most frameworks use a simple while loop to manage the agent's life cycle.

Why this is dangerous for production:

Zombies processes: If the container restarts, the state variable is wiped.

Double-spending: If a crash happens after a tool call but before the state is saved, the recovery process might re-run the tool (e.g., charging a customer twice).

Context Bloat: There is no native way to offload and rehydrate state without manual boilerplate.

The Solution: Event-Sourced Execution (Calljmp)
To solve this, we need to treat the agent's execution as a Durable Workflow. In Calljmp, we implement a pattern where every side effect is indexed.

Deterministic Replay When an agent recovers from a crash, it doesn't just "restart." It re-runs the code, but the context.step() function intercepts the call. If it sees that Step 1 was already completed, it returns the cached result immediately without hitting the LLM or the Database.
Virtual Sharding of State Instead of a monolithic JSON blob, Calljmp shards the agent's memory into discrete, addressable steps. This allows for:

Binary-level persistence: Saving state at the instruction level.

Cold-start optimization: Only loading the necessary context for the current step.

Handling Non-Deterministic Tooling The biggest challenge is ensuring that Date.now() or Math.random() don't break the replay. A truly durable runtime must provide wrapped primitives to ensure the execution path remains identical during recovery.

Conclusion
Building "Smart" agents is about the LLM. Building "Reliable" agents is about the Runtime. We are building Calljmp to be that runtime - a layer that makes your agent's reasoning loop crash-proof and immortal.