LangGraph is a $20/month tax for poor architecture. If you're building a simple state machine for LLM workflows, you're overpaying for abstraction you don't need.
Key cost drivers in LangGraph:
* Managed orchestration overhead. You're paying for their infra to run your graph.
* Vendor lock-in for workflow definitions. Migrating is non-trivial.
* For deterministic flows, it's an expensive wrapper around `if` statements.
Build your own for 90% less. A lightweight DAG runner using Python's `asyncio` and persistent state (e.g., Redis) handles most use cases. Example core logic:
```python
class StateMachine:
def __init__(self, redis_client):
self.nodes = {}
self.redis = redis_client
async def execute(self, workflow_id, start_node):
current_state = await self.redis.get(f"state:{workflow_id}")
# ... execute node logic, update state, traverse edges
# Cost: ~$5/month for the Redis instance.
```
Reserve LangGraph for complex, dynamic routing that truly needs its `StateGraph` and built-in persistence. For linear chains or bounded loops? Custom wins on cost and control every time.
cost per transaction is the only metric