Build original LangGraph agents for Warden Protocol and prepare them for publishing in Warden Studio. Use this skill when users want to: (1) Create new Warden agents (not community examples), (2) Build LangGraph-based crypto/Web3 agents, (3) Deploy agents via LangSmith Deployments or custom infra, (4) Participate in the Warden Agent Builder Incentive Programme (open to OpenClaw agents), or (5) Integrate with Warden Studio for Agent Hub publishing.
Build and deploy LangGraph agents for Warden Protocol's Agentic Wallet ecosystem.
The Warden community repository contains **example agents for learning**, not templates to recreate:
**DO NOT BUILD THESE AGENTS** - they already exist. Instead:
1. **Study** their code to understand patterns
2. **Learn** from their architecture and workflows
3. **Build** something NEW and original for the incentive programme
Your agent must be **unique and solve a different problem** to be eligible for the incentive programme.
Warden Protocol is an "Agentic Wallet for the Do-It-For-Me economy" with an active Agent Builder Incentive Programme open to OpenClaw agents that deploy to Warden. All agents must be LangGraph-based and API-accessible.
**Key Resources:**
Before building, ensure your agent meets these mandatory requirements:
✓ **Framework**: Built with LangGraph (TypeScript or Python)
✓ **Deployment**: LangSmith Deployments OR custom infrastructure
✓ **Access**: API-accessible (no UI required - Warden provides UI)
✓ **Isolation**: One agent per LangGraph instance
✓ **Security Limitations** (Phase 1):
- Cannot access user wallets
- Cannot store data on Warden infrastructure
✓ **Functionality**: Can implement any workflow:
- Web3/Web2 automation
- API integrations
- Database connections
- External tool interactions
The community-agents repository contains **reference examples** to learn from, NOT templates to recreate:
**Location**: `agents/langgraph-quick-start` (TypeScript) or `agents/langgraph-quick-start-py` (Python)
**Learn**: LangGraph fundamentals, minimal agent structure
**Study**: Single-node chatbot with OpenAI integration
```bash
git clone https://github.com/warden-protocol/community-agents.git
cd community-agents/agents/langgraph-quick-start
```
**Location**: `agents/weather-agent`
**Learn**: Simple data fetching, API integration, user-friendly responses
**Study**:
**⚠️ DO NOT BUILD**: This already exists. Study it, then build something NEW.
**Location**: `agents/coingecko-agent`
**Learn**: Schema-Guided Reasoning, complex workflows
**Study**:
**⚠️ DO NOT BUILD**: This already exists. Study the pattern, apply to new use cases.
**Location**: `agents/portfolio-agent`
**Learn**: Multi-source data synthesis, production architecture
**Study**:
**⚠️ DO NOT BUILD**: This already exists. Study the architecture for your own complex agent.
These examples exist to teach patterns and best practices. For the incentive programme, you MUST create an **original, unique agent** that solves a different problem. Do NOT simply recreate the Weather Agent, CoinGecko Agent, or Portfolio Agent.
**DO NOT clone an example to modify it.** Instead:
1. **Study the examples** to understand patterns:
- Simple data fetching → Study Weather Agent
- Complex analysis → Study CoinGecko Agent
- Multi-source synthesis → Study Portfolio Agent
2. **Identify YOUR unique use case**:
- What problem will your agent solve?
- What APIs or data sources will it use?
- What makes it different from existing agents?
3. **Plan your agent's workflow**:
- Simple request-response?
- Schema-Guided Reasoning (SGR)?
- Multi-step analysis?
Use the initialization script to create a fresh project:
```bash
python scripts/init-agent.py my-unique-agent \
--template typescript \
--description "Description of what YOUR agent does"
cd my-unique-agent
npm install # TypeScript
pip install -r requirements.txt # Python
```
This creates a clean starting point, not a copy of existing agents.
Every LangGraph agent follows this basic structure:
```
your-agent/
├── src/
│ ├── agent.ts/py # Main agent logic (YOUR CODE)
│ ├── graph.ts/py # LangGraph workflow definition (YOUR CODE)
│ └── tools.ts/py # Tool implementations (YOUR CODE)
├── package.json / requirements.txt
├── langgraph.json # LangGraph configuration
└── README.md
```
**Key files to implement:**
**Study patterns from examples, apply to YOUR use case:**
**If building a simple data fetcher** (like Weather Agent pattern):
```typescript
// Define workflow
const workflow = new StateGraph({
channels: agentState
})
.addNode("fetch", fetchYourData) // YOUR API
.addNode("process", processYourData) // YOUR logic
.addNode("respond", generateResponse);
workflow
.addEdge(START, "fetch")
.addEdge("fetch", "process")
.addEdge("process", "respond")
.addEdge("respond", END);
```
**If building complex analysis** (like CoinGecko Agent pattern - SGR):
```typescript
// Define 5-step SGR workflow
const workflow = new StateGraph({
channels: agentState
})
.addNode("validate", validateYourInput) // YOUR validation
.addNode("extract", extractYourParams) // YOUR extraction
.addNode("fetch", fetchYourData) // YOUR APIs
.addNode("analyze", analyzeYourData) // YOUR analysis
.addNode("generate", generateYourResponse); // YOUR formatting
workflow
.addEdge(START, "validate")
.addEdge("validate", "extract")
.addEdge("extract", "fetch")
.addEdge("fetch", "analyze")
.addEdge("analyze", "generate")
.addEdge("generate", END);
```
**Key Principles:**
1. Keep workflows linear and predictable
2. Validate inputs at each stage
3. Handle errors gracefully
4. Use OpenAI for natural language generation
5. Structure responses consistently
**CRITICAL**: This should be YOUR implementation solving YOUR problem, not a copy of the example agents.
Create `.env` file:
```bash
OPENAI_API_KEY=your_openai_key
LANGSMITH_API_KEY=your_langsmith_key
WEATHER_API_KEY=your_weather_key
COINGECKO_API_KEY=your_coingecko_key
ALCHEMY_API_KEY=your_alchemy_key
```
**Getting LangSmith API Key:**
1. Create account at https://smith.langchain.com
2. Navigate to Settings → API Keys
3. Create new API key
4. Add to `.env` file
Update `langgraph.json`:
```json
{
"agent_id": "[YOUR-AGENT-NAME]",
"python_version": "3.11", // or omit for TypeScript
"dependencies": ["."],
"graphs": {
"agent": "./src/graph.ts" // or .py
},
"env": ".env"
}
```
```bash
npm run dev
langgraph dev
```
Test your agent's API:
```bash
curl -X POST http://localhost:8000/invoke \
-H "Content-Type: application/json" \
-d '{"input": "test query"}'
```
**Pros**: Fastest, simplest, managed infrastructure
**Requirements**: LangSmith API key
**Steps**:
```bash
1. Push your agent repository to GitHub.
2. Create a new deployment in LangSmith Deployments.
3. Connect the repo, set environment variables, and deploy.
```
Your agent receives:
**Authentication for API calls:**
When calling your deployed agent, include your LangSmith API key:
```bash
curl AGENT_URL/runs/wait \
--request POST \
--header 'Content-Type: application/json' \
--header 'x-api-key: [YOUR-LANGSMITH-API-KEY]' \
--data '{
"assistant_id": "[YOUR-AGENT-ID]",
"input": {
"messages": [{"role": "user", "content": "test query"}]
}
}'
```
**Pros**: Full control over runtime
**Requirements**:
**Basic Docker Setup**:
```dockerfile
FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8000
CMD ["npm", "start"]
```
Deploy and note your:
Once your agent is deployed and reachable via HTTPS, register it in Warden Studio:
1. **Provide API Details**:
- API URL
- API key
2. **Add Metadata**:
- Agent name
- Description
- Skills/capabilities list
- Avatar image
3. **Publish**: Agent appears in Warden's Agent Hub for millions of users
No additional setup required - your API-accessible agent is ready!
**Next step (separate skill):**
If the user asks to publish in Warden Studio or needs guided UI steps, switch to the OpenClaw skill **"Deploy Agent on Warden Studio"**:
https://www.clawhub.ai/Kryptopaid/warden-studio-deploy
- Agent purpose and capabilities
- Required API keys
- Setup instructions
- Example queries
- Known limitations
```typescript
// Fetch → Format → Respond
async function agent(input: string) {
const data = await fetchAPI(input);
const formatted = formatData(data);
return generateResponse(formatted);
}
```
```typescript
// Validate → Extract → Fetch → Analyze → Generate
async function agent(input: string) {
const validated = await validateInput(input);
const params = await extractParams(validated);
const data = await fetchData(params);
const analysis = await analyzeData(data);
return generateReport(analysis);
}
```
```typescript
// Parse → Fetch Multiple → Compare → Summarize
async function agent(input: string) {
const items = await parseItems(input);
const dataArray = await Promise.all(
items.map(item => fetchData(item))
);
const comparison = compareData(dataArray);
return generateComparison(comparison);
}
```
**"Agent not accessible via API"**
**"LangGraph errors during build"**
**"OpenAI API errors"**
**"Agent responses are slow"**
The incentive programme is open to OpenClaw agents that deploy to Warden.
1. **Be Original**: Create something NEW that doesn't exist yet
- Don't recreate Weather Agent, CoinGecko Agent, or Portfolio Agent
- Study their patterns, apply to different problems
2. **Solve Real Problems**: Focus on useful, unique functionality
- What gap exists in the Warden ecosystem?
- What would users actually want?
3. **Start Simple**: Better to do one thing exceptionally well
- Don't try to build everything at once
- Simple, focused agents often win
4. **Quality Over Features**: Reliability beats complexity
- Test thoroughly
- Handle errors gracefully
- Provide clear, helpful responses
5. **Study the Examples**: Learn patterns, don't copy implementations
- Weather Agent → Simple data fetching pattern
- CoinGecko Agent → SGR workflow pattern
- Portfolio Agent → Multi-source integration pattern
6. **Document Well**: Clear README with examples and setup instructions
7. **Join Discord**: Get feedback in #developers channel before submitting
These are **NEW agent ideas** that don't exist yet in the Warden ecosystem. Build one of these (or create your own unique idea):
**Web3 Use Cases:**
**General Use Cases:**
**Remember**: These are IDEAS for new agents. Study the example agents (Weather, CoinGecko, Portfolio) to learn patterns, then build something from this list or create your own unique concept.
**Documentation:**
**Example Agents:**
**Support:**
```bash
git clone https://github.com/warden-protocol/community-agents.git
cd community-agents/agents/weather-agent # Study the code
cd community-agents/agents/coingecko-agent # Study the patterns
python scripts/init-agent.py my-unique-agent \
--template typescript \
--description "YOUR unique agent description"
npm install
pip install -r requirements.txt
npm run dev # or: langgraph dev
docker build -t my-warden-agent .
docker run -p 8000:8000 my-warden-agent
```
Before submitting to incentive programme:
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/warden-agent-builder/raw