from Hacker News

Show HN: Pickaxe – A TypeScript library for building AI agents

by abelanger on 6/20/25, 4:07 PM with 26 comments

Hey HN, Gabe and Alexander here from Hatchet. Today we're releasing Pickaxe, a Typescript library to build AI agents which are scalable and fault-tolerant.

Here's a demo: https://github.com/user-attachments/assets/b28fc406-f501-442...

Pickaxe provides a simple set of primitives for building agents which can automatically checkpoint their state and suspend or resume processing (also known as durable execution) while waiting for external events (like a human in the loop). The library is based on common patterns we've seen when helping Hatchet users run millions of agent executions per day.

Unlike other tools, Pickaxe is not a framework. It does not have any opinions or abstractions for implementing agent memory, prompting, context, or calling LLMs directly. Its only focus is making AI agents more observable and reliable.

As agents start to scale, there are generally three big problems that emerge: 1. Agents are long-running compared to other parts of your application. Extremely long-running processes are tricky because deploying new infra or hitting request timeouts on serverless runtimes will interrupt their execution. 2. They are stateful: they generally store internal state which governs the next step in the execution path 3. They require access to lots of fresh data, which can either be queried during agent execution or needs to be continuously refreshed from a data source.

(These problems are more specific to agents which execute remotely -- locally running agents generally don't have these problems)

Pickaxe is designed to solve these issues by providing a simple API which wraps durable execution infrastructure for agents. Durable execution is a way of automatically checkpointing the state of a process, so that if the process fails, it can automatically be replayed from the checkpoint, rather than starting over from the beginning. This model is also particularly useful when your agent needs to wait for an external event or human review in order to continue execution. To support this pattern, Pickaxe uses a Hatchet feature called `waitFor` which durably registers a listener for an event, which means that even if the agent isn't actively listening for the event, it is guaranteed to be processed by Hatchet and stored in the execution history and resume processing. This infrastructure is powered by what is essentially a linear event log, which stores the entire execution history of an agent in a Postgres database managed by Hatchet.

Full docs are here: https://pickaxe.hatchet.run/

We'd greatly appreciate any feedback you have and hope you get the chance to try out Pickaxe.

  • by movedx01 on 6/23/25, 8:08 PM

    This is great, and I keep my fingers crossed for Hatchet!

    One use case I imagine is key here is background/async agents, so OpenAI Codex/Jules style, so that's great if I can durably run them with Pickaxe(btw I belive I've read somewhere in temporal docs or some webinar that Codex was built on that ;), but how do I get that real-time and resumable message stream back to the client? The user might reload the page or return after 15 minutes, etc. I wasn't able to think of an elegant way to model this in a distributed system.

  • by jskalc92 on 6/23/25, 7:47 PM

    If I understand it correctly, tools and agents run() method works in a similar way to react hooks, correct?

    Depending on execution order, tool is either called or a cached value returned. That way local state can be replayed, and that's why "no side effects" rule is in place.

    I like it. Just, what's the recommended way to have a chat assistant agent with multiple tools? Message history would need to be passed to the very top-level agent.run call, isn't it?

  • by necatiozmen on 6/28/25, 8:47 AM

    Cool work, durable execution and resumability are hugely underrated problems in the agent space, especially once you move beyond toy demos. Love the checkpointing + waitFor pattern, and the Hatchet integration makes a lot of sense for infraheavy setups.

    I’m one of the maintainers of VoltAgent , a TypeScript framework focused on agent composition, modular memory/tool flows, and built-in observability (tracing, input/output history..) (https://github.com/VoltAgent/voltagent)

    We’re solving a different layer of the stack more on the orchestration/dev experience sid.

    Definitely bookmarking this.

  • by blixt on 6/23/25, 7:48 PM

    I see the API is rarely mentioning exact message structure (system prompt, assistant/user history, etc) or the choice of model (other than defaultLanguageModel). And it's not immediately clear to me how `toolbox.pickAndRun` can access any context from an ongoing agentic flow other than within the one prompt. But this is just from skimming the docs, maybe all of this is supported?

    The reason I ask is because I've had a lot of success using different models for different tasks, constructing the system prompt specifically for each task, and also choosing between the "default" long assistant/tool_call/user/(repeat) message history vs. constantly pruning it (bad for caching but sometimes good for performance). And it would be nice to know a library like this could allow experimentation of these strategies.

  • by gerardosuarez on 6/25/25, 3:45 PM

    It would be great to have a section in the README about how the code looks without using the library, contrasting it with the example you already have. I would need a significant time-saving reason to use a new external library. This is because, for new libraries like yours, we don't know how long you plan to support it. For that reason, using an external library for a core part of my business is a huge risk for me.

    My use case: cursor for open-source terminal-based coding agents.

  • by golergka on 6/23/25, 7:58 PM

    Fantastic. That's exactly what I wanted to make for a long time but never got around to, writing ad-hoc, lacking, overlapping stuff each time.

  • by randomcatuser on 6/20/25, 4:33 PM

    Oh this is really cool! I was building out a bit of this with Restate this past week, but this seems really well put together :) will give it a try!

  • by j_rosenthal on 6/23/25, 11:27 PM

    The library name is confusing given https://pickaxe.co/, a nicely done low code platform for building/monetizing chatbots and agents that's been around for 2.5 years or so.

    (No connection to pickaxe.co other than using the platform)

  • by almosthere on 6/20/25, 4:10 PM

    What I really like about it, is that this kind of project helps people learn what an agent is.

  • by awaseem on 6/23/25, 8:33 PM

    Love to see more frameworks like this in the Typescript eco-system! How does this compare to Mastra: https://mastra.ai/

  • by muratsu on 6/24/25, 12:36 AM

    How does this compare to agent-kit by inngest?

  • by zegl on 6/20/25, 5:10 PM

    As a long time Hatchet user, I understand why you’ve created this library, but it also disappoints me a little bit. I wish more engineering time was spent on making the core platform more stable and performant.