Pocket

What is Pocket?

Installation

Quick Install (Recommended)

# macOS and Linux via Homebrew (pre-built binary)
brew install agentstation/tap/pocket
# Or use our install script
curl -sSL https://raw.githubusercontent.com/agentstation/pocket/master/install.sh | bash

Other Installation Methods

Quick Start

# agent.yaml
name: simple-agent
start: think
nodes:
 - name: think
 type: http
 config:
 url: "https://api.openai.com/v1/chat/completions"
 method: POST
 headers:
 Authorization: "Bearer ${OPENAI_API_KEY}"
 body:
 model: "gpt-4"
 messages:
 - role: "system"
 content: "You are a helpful assistant. Respond with either SEARCH: <query> or ANSWER: <response>"
 - role: "user"
 content: "{{.question}}"
 
 - name: route
 type: conditional
 config:
 conditions:
 - if: '{{contains .choices[0].message.content "SEARCH:"}}'
 then: search
 - if: '{{contains .choices[0].message.content "ANSWER:"}}'
 then: respond
 
 - name: search
 type: http
 config:
 url: "https://api.search.com/v1/search"
 params:
 q: '{{.query}}'
 
 - name: respond
 type: echo
 config:
 message: '{{.answer}}'
connections:
 - from: think
 to: route
 - from: search
 to: think # Loop back with search results

pocket run agent.yaml --input '{"question": "What is the weather in Tokyo?"}'

Why Pocket?

🌐 Language Agnostic

🧠 Dynamic Routing

🚀 Production Ready

📦 Zero Dependencies

Key Features

Build LLM Agents That Think and Act

nodes:
 - name: agent-brain
 type: lua
 config:
 script: |
 -- Analyze the task and decide what to do
 local task = input.task
 if string.find(task, "calculate") then
 return {action = "calculator", expression = task}
 elseif string.find(task, "search") then
 return {action = "web_search", query = task}
 else
 return {action = "direct_answer", task = task}
 end

Write Plugins in Any Language

-- sentiment.lua
function exec(input)
 local text = input.text:lower()
 local positive = {"good", "great", "excellent", "love"}
 local negative = {"bad", "terrible", "hate", "awful"}
 
 local score = 0
 for _, word in ipairs(positive) do
 if string.find(text, word) then score = score + 1 end
 end
 for _, word in ipairs(negative) do
 if string.find(text, word) then score = score - 1 end
 end
 
 return {
 sentiment = score > 0 and "positive" or score < 0 and "negative" or "neutral",
 score = score
 }
end

export function analyzeImage(input: ImageData): Analysis {
 // Your image processing logic compiled to WASM
 return { objects: detected, confidence: 0.95 };
}

Define Complex Workflows in Simple YAML

name: data-pipeline
start: fetch
nodes:
 - name: fetch
 type: parallel # Fetch from multiple sources concurrently
 config:
 tasks:
 - {type: http, config: {url: "${API1}"}}
 - {type: http, config: {url: "${API2}"}}
 
 - name: merge
 type: aggregate
 config:
 mode: combine
 
 - name: validate
 type: validate
 config:
 schema:
 type: object
 required: [id, data]

Production Features Built-In

📚 Documentation

Examples

LLM Agent with Tools

name: research-agent
start: think
nodes:
 - name: think
 type: llm # Uses OpenAI, Anthropic, or local models
 config:
 prompt: |
 You have access to: calculator, web_search, file_reader
 User query: {{.query}}
 Respond with the tool to use and parameters.

 - name: use-tool
 type: router
 config:
 routes:
 calculator: calc-node
 web_search: search-node
 file_reader: read-node

Data Processing Pipeline

name: etl-pipeline
start: extract
nodes:
 - name: extract
 type: file
 config:
 path: "data/*.json"
 
 - name: transform
 type: transform
 config:
 jq: 'map(select(.active) | {id, name, value: .price * 1.1})'
 
 - name: load
 type: http
 config:
 url: "${WAREHOUSE_API}"
 method: POST

Plugins

# Install a plugin
pocket plugin install github.com/example/pocket-redis
# Use in your workflow
nodes:
 - name: cache-result
 type: redis-set # From the plugin
 config:
 key: "result:{{.id}}"
 value: "{{.data}}"

Contributing

# Run tests
go test -race ./...
# Build
make build
# Run benchmarks
make bench

Using as a Go Library

package main
import (
 "context"
 "github.com/agentstation/pocket"
)
func main() {
 // Create nodes
 process := pocket.NewNode[Input, Output]("process",
 pocket.Steps{
 Exec: func(ctx context.Context, input any) (any, error) {
 // Your logic here
 return processData(input.(Input))
 },
 },
 )
 
 // Build and run workflow
 graph := pocket.NewGraph(process, pocket.NewStore())
 result, _ := graph.Run(context.Background(), myInput)
}

Development

Prerequisites

Building from Source

git clone https://github.com/agentstation/pocket.git
cd pocket
go build -o pocket cmd/pocket/main.go

Architecture

Go-Specific Information

License

Acknowledgments