lexBuild 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.
Install via ClawdBot CLI:
clawdbot install kulotzkih/lexBuild 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:
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):
ā Functionality: Can implement any workflow:
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
git clone https://github.com/warden-protocol/community-agents.git
cd community-agents/agents/langgraph-quick-startLocation: 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:
Use the initialization script to create a fresh project:
# Create your unique agent
python scripts/init-agent.py my-unique-agent \
--template typescript \
--description "Description of what YOUR agent does"
# Navigate to project
cd my-unique-agent
# Install dependencies
npm install # TypeScript
# OR
pip install -r requirements.txt # PythonThis 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.mdKey files to implement:
graph.ts/py - Define your workflow (validate ā process ā respond)agent.ts/py - Implement your core logictools.ts/py - Integrate external APIs specific to YOUR agent's purposeStudy patterns from examples, apply to YOUR use case:
If building a simple data fetcher (like Weather Agent pattern):
// 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):
// 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:
CRITICAL: This should be YOUR implementation solving YOUR problem, not a copy of the example agents.
Create .env file:
# Required
OPENAI_API_KEY=your_openai_key
# Required for LangSmith Deployments (cloud)
LANGSMITH_API_KEY=your_langsmith_key
# Optional - based on your tools
WEATHER_API_KEY=your_weather_key
COINGECKO_API_KEY=your_coingecko_key
ALCHEMY_API_KEY=your_alchemy_keyGetting LangSmith API Key:
.env fileUpdate langgraph.json:
{
"agent_id": "[YOUR-AGENT-NAME]",
"python_version": "3.11", // or omit for TypeScript
"dependencies": ["."],
"graphs": {
"agent": "./src/graph.ts" // or .py
},
"env": ".env"
}# TypeScript
npm run dev
# Python
langgraph devTest your agent's API:
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:
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:
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:
FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8000
CMD ["npm", "start"]Deploy and note your:
https://your-domain.com/agentOnce your agent is deployed and reachable via HTTPS, register it in Warden Studio:
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
// Fetch ā Format ā Respond
async function agent(input: string) {
const data = await fetchAPI(input);
const formatted = formatData(data);
return generateResponse(formatted);
}// 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);
}// 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.
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:
community-agents/docs/langgraph-quick-start-ts.mdcommunity-agents/docs/langgraph-quick-start-py.mdcommunity-agents/docs/deploy.mdExample Agents:
agents/weather-agent/README.mdagents/coingecko-agent/README.mdagents/portfolio-agent/README.mdSupport:
# Study example agents (DON'T BUILD THESE)
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
# Create YOUR new agent
python scripts/init-agent.py my-unique-agent \
--template typescript \
--description "YOUR unique agent description"
# Install dependencies (TypeScript)
npm install
# Install dependencies (Python)
pip install -r requirements.txt
# Test locally
npm run dev # or: langgraph dev
# Deploy (LangSmith Deployments)
# Use the LangSmith Deployments UI after pushing to GitHub
# Build Docker image (for self-hosting)
docker build -t my-warden-agent .
# Run Docker container
docker run -p 8000:8000 my-warden-agentBefore submitting to incentive programme:
Generated Mar 1, 2026
An agent that monitors multiple DeFi protocols across chains to identify and execute optimal yield farming strategies. It analyzes APY, risks, and gas costs, then suggests or automates rebalancing for users' liquidity positions.
An agent that tracks NFT collections, floor prices, and rarity scores to provide insights on buying, selling, or holding decisions. It integrates with marketplaces like OpenSea and Blur for real-time data and trend analysis.
An agent that monitors cross-chain bridge transactions for security and efficiency, alerting users to delays, fees, or anomalies. It uses APIs from bridges like Wormhole and LayerZero to ensure safe asset transfers.
An agent that aggregates transaction data from wallets and exchanges to generate tax reports compliant with regulations. It integrates with services like CoinTracker or Koinly APIs for automated calculations and filings.
An agent that analyzes smart contract code for vulnerabilities by integrating with tools like Slither or MythX. It provides summaries of risks and recommendations, aiding developers in security audits before deployment.
Charge users a monthly fee for accessing the agent's API, with tiered plans based on usage limits or advanced features. This model ensures recurring revenue and scales with user growth in the Web3 ecosystem.
Earn a small percentage fee on transactions facilitated by the agent, such as DeFi swaps or NFT trades. This aligns incentives with user success and can generate revenue from high-volume activities.
Offer customized versions of the agent to businesses or protocols, with licensing fees for integration into their platforms. This includes white-label solutions and dedicated support for specific use cases.
š¬ Integration Tip
Focus on robust API design and error handling to ensure reliability when integrating with external Web3 services, as network delays and rate limits are common challenges.
Connect Claude to Clawdbot instantly and keep it connected 24/7. Run after setup to link your subscription, then auto-refreshes tokens forever.
ERC-8004 Trustless Agents - Register, discover, and build reputation for AI agents on Ethereum. Use when registering agents on-chain, querying agent registries, giving/receiving reputation feedback, or interacting with the AI agent trust layer.
Autonomous crypto trading on Base via Bankr. Use for trading tokens, monitoring launches, executing strategies, or managing a trading portfolio. Triggers on "trade", "buy", "sell", "launch", "snipe", "profit", "PnL", "portfolio balance", or any crypto trading task on Base.
Deploy ERC20 tokens on Base using Clanker SDK. Create tokens with built-in Uniswap V4 liquidity pools. Supports Base mainnet and Sepolia testnet. Requires PRIVATE_KEY in config.
Query DeFi portfolio data across 50+ chains via Zapper's GraphQL API. Use when the user wants to check wallet balances, DeFi positions, NFT holdings, token prices, or transaction history. Supports Base, Ethereum, Polygon, Arbitrum, Optimism, and more. Requires ZAPPER_API_KEY.
Interact with Solana blockchain via Helius APIs. Create/manage wallets, check balances (SOL + tokens), send transactions, swap tokens via Jupiter, and monitor addresses. Use for any Solana blockchain operation, crypto wallet management, token transfers, DeFi swaps, or portfolio tracking.