You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Pickaxe is a simple Typescript library for building AI agents that are fault-tolerant and scalable. It handles the complexities of durable execution, queueing and scheduling, allowing you to focus on writing core business logic. [It is not a framework](#philosophy).
18
+
Icepick is a simple Typescript library for building AI agents that are fault-tolerant and scalable. It handles the complexities of durable execution, queueing and scheduling, allowing you to focus on writing core business logic. [It is not a framework](#philosophy).
19
19
20
-
Everything in Pickaxe is just a function that **you have written**, which makes it easy to integrate with your existing codebase and business logic. You can build agents that call tools, other agents, or any other functions you define:
20
+
Everything in Icepick is just a function that **you have written**, which makes it easy to integrate with your existing codebase and business logic. You can build agents that call tools, other agents, or any other functions you define:
This will prompt you to create a new Pickaxe project from a template to see an end to end example of Pickaxe in action.
81
+
This will prompt you to create a new Icepick project from a template to see an end to end example of Icepick in action.
82
82
83
-
For a full quickstart, check out our [documentation](https://pickaxe.hatchet.run/quickstart).
83
+
For a full quickstart, check out our [documentation](https://icepick.hatchet.run/quickstart).
84
84
85
85
## Benefits
86
86
87
-
Pickaxe is centered around the benefit of **durable execution**, which creates automatic checkpoints for agents so that they can easily recover from failure or wait for external events for a very long time without consuming resources. This is achieved by using a durable task queue called [Hatchet](https://github.com/hatchet-dev/hatchet).
87
+
Icepick is centered around the benefit of **durable execution**, which creates automatic checkpoints for agents so that they can easily recover from failure or wait for external events for a very long time without consuming resources. This is achieved by using a durable task queue called [Hatchet](https://github.com/hatchet-dev/hatchet).
88
88
89
-
Additionally, Pickaxe agents are:
89
+
Additionally, Icepick agents are:
90
90
91
91
-**💻 Code-first** - agents are defined as code and are designed to integrate with your business logic.
92
-
-**🌐 Distributed** - all agents and tools run across a fleet of machines, where scheduling is handled gracefully by Pickaxe. When your underlying machine fails, Pickaxe takes care of rescheduling and resuming the agent on a different machine.
92
+
-**🌐 Distributed** - all agents and tools run across a fleet of machines, where scheduling is handled gracefully by Icepick. When your underlying machine fails, Icepick takes care of rescheduling and resuming the agent on a different machine.
93
93
-**⚙️ Configurable** - simple configuration for retries, rate limiting, concurrency control, and much more
94
-
-**☁️ Runnable anywhere** - Pickaxe agents can run on any container-based platform (Hatchet, Railway, Fly.io, Porter, Kubernetes, AWS ECS, GCP Cloud Run)
94
+
-**☁️ Runnable anywhere** - Icepick agents can run on any container-based platform (Hatchet, Railway, Fly.io, Porter, Kubernetes, AWS ECS, GCP Cloud Run)
95
95
96
96
## Scalability
97
97
98
-
Pickaxe is designed for scale: specifically, massive throughput and parallelism. Hatchet has run agentic workloads which spawn hundreds of thousands of tasks for a single execution, and runs billions of tasks per month.
98
+
Icepick is designed for scale: specifically, massive throughput and parallelism. Hatchet has run agentic workloads which spawn hundreds of thousands of tasks for a single execution, and runs billions of tasks per month.
99
99
100
100
## Philosophy
101
101
102
-
Pickaxe is not a framework. Agents and tools are simply functions that you have written. This means you can choose or build the best memory, knowledge, reasoning, or integrations. It does not impose any constraints on how you design your tools, call LLMs, or implement features like agent memory. Pickaxe is opinionated about the infrastructure layer of your agents, but not about the implementation details of your agents.
102
+
Icepick is not a framework. Agents and tools are simply functions that you have written. This means you can choose or build the best memory, knowledge, reasoning, or integrations. It does not impose any constraints on how you design your tools, call LLMs, or implement features like agent memory. Icepick is opinionated about the infrastructure layer of your agents, but not about the implementation details of your agents.
103
103
104
104
## Documentation
105
105
106
106
### Concepts
107
107
108
-
-[**Overview**](https://pickaxe.hatchet.run/concepts/overview) - an overview of the Pickaxe execution model
109
-
-[**Agents**](https://pickaxe.hatchet.run/concepts/agents) - agents are functions which call other tools and agents.
110
-
-[**Tools**](https://pickaxe.hatchet.run/concepts/tools) - tools are functions that perform specific tasks and can be called by agents.
111
-
-[**Toolbox**](https://pickaxe.hatchet.run/concepts/toolbox) - a toolbox is a collection of tools with AI-powered selection capabilities.
108
+
-[**Overview**](https://icepick.hatchet.run/concepts/overview) - an overview of the Icepick execution model
109
+
-[**Agents**](https://icepick.hatchet.run/concepts/agents) - agents are functions which call other tools and agents.
110
+
-[**Tools**](https://icepick.hatchet.run/concepts/tools) - tools are functions that perform specific tasks and can be called by agents.
111
+
-[**Toolbox**](https://icepick.hatchet.run/concepts/toolbox) - a toolbox is a collection of tools with AI-powered selection capabilities.
Pickaxe is **not a framework**. It is not opinionated on how you structure your LLM calls, business logic, prompts, or context; we expect you to write these yourself (though Pickaxe does have a few utilities for tool-picking and bundles the AI SDK for calling LLMs).
133
+
Icepick is **not a framework**. It is not opinionated on how you structure your LLM calls, business logic, prompts, or context; we expect you to write these yourself (though Icepick does have a few utilities for tool-picking and bundles the AI SDK for calling LLMs).
134
134
135
-
Pickaxe is designed to be extended and modified -- for example, you could build your own agent library on top of Pickaxe.
135
+
Icepick is designed to be extended and modified -- for example, you could build your own agent library on top of Icepick.
136
136
137
137
### vs Temporal
138
138
139
-
Pickaxe's execution model is most similar to [Temporal](https://github.com/temporalio/temporal) with a simplified execution model and with more control for workflow scheduling:
139
+
Icepick's execution model is most similar to [Temporal](https://github.com/temporalio/temporal) with a simplified execution model and with more control for workflow scheduling:
@@ -156,7 +156,7 @@ Pickaxe's execution model is most similar to [Temporal](https://github.com/tempo
156
156
157
157
## Agent Best Practices
158
158
159
-
When writing agents with Pickaxe, it's useful to follow these rules:
159
+
When writing agents with Icepick, it's useful to follow these rules:
160
160
161
161
1. Agents should be **stateless reducers** with **no side effects**. They should not depend on external API calls, database calls, or local disk calls; their entire state should be determined by the results of their tool calls. See the [technical deep-dive](#technical-deep-dive) for more information.
162
162
@@ -170,7 +170,7 @@ Contributions are welcome! Please start a discussion in [Discord](https://hatche
170
170
171
171
## Technical Deep-Dive
172
172
173
-
Pickaxe is a utility layer built on top of [Hatchet](https://github.com/hatchet-dev/hatchet). It is built on the concept of a **durable task queue**, which means that every task which gets called in Hatchet is stored in a database. This is useful because tasks can easily be replayed and recover from failure, even when the underlying hardware crashes. Another way to look at it: Hatchet makes _distributed systems incredibly easy to deploy and maintain_.
173
+
Icepick is a utility layer built on top of [Hatchet](https://github.com/hatchet-dev/hatchet). It is built on the concept of a **durable task queue**, which means that every task which gets called in Hatchet is stored in a database. This is useful because tasks can easily be replayed and recover from failure, even when the underlying hardware crashes. Another way to look at it: Hatchet makes _distributed systems incredibly easy to deploy and maintain_.
174
174
175
175
For agents, this is particularly useful because they are extremely long-running, and thus need to be resilient to hardware failure. Agents also need to manage third-party rate limits and need concurrency control to prevent the system from getting overwhelmed.
176
176
@@ -185,7 +185,7 @@ Event log:
185
185
-> Start extract_from_document...
186
186
```
187
187
188
-
Now, let's say that the machine which the agent is running on crashes during the last step. In order to recover from failure, Pickaxe will automatically replay all steps up to this point in the execution history:
188
+
Now, let's say that the machine which the agent is running on crashes during the last step. In order to recover from failure, Icepick will automatically replay all steps up to this point in the execution history:
189
189
190
190
```
191
191
Event log:
@@ -197,11 +197,11 @@ Event log:
197
197
-> (later) Finish extract_from_document
198
198
```
199
199
200
-
In other words, the execution history is cached by Pickaxe, which allows the agent to recover gracefully from failure, instead of having to replay a bunch of work. Another way to think about it is that the agent automatically "checkpoints" its state.
200
+
In other words, the execution history is cached by Icepick, which allows the agent to recover gracefully from failure, instead of having to replay a bunch of work. Another way to think about it is that the agent automatically "checkpoints" its state.
201
201
202
202
This execution model is much more powerful when there's a requirement to wait for external systems, like a human reviewer or external event. Building a system that's resilient to failure becomes much more difficult, because if the agent starts from scratch, it may have lost the event which allowed execution to continue. In this model, the event automatically gets stored and replayed.
203
203
204
-
Beyond Hatchet, there are two other points of inspiration for Pickaxe:
204
+
Beyond Hatchet, there are two other points of inspiration for Icepick:
205
205
206
-
-[12-factor agents](https://github.com/humanlayer/12-factor-agents) -- this is the foundation for why Pickaxe advocates owning your control flow, context window, and prompts
207
-
- Anthropic's [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) -- we have ensured that each pattern documented in Anthropic's post are compatible with Pickaxe
206
+
-[12-factor agents](https://github.com/humanlayer/12-factor-agents) -- this is the foundation for why Icepick advocates owning your control flow, context window, and prompts
207
+
- Anthropic's [Building Effective Agents](https://www.anthropic.com/engineering/building-effective-agents) -- we have ensured that each pattern documented in Anthropic's post are compatible with Icepick
"publish:ci": "rm -rf ./dist && npm run dump-version && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks"
0 commit comments