Integrate Nonhumans Agents with AI Frameworks and Services

Nonhumans is designed to slot into your existing stack, not replace it. Whether you’re orchestrating agents with LangChain or CrewAI, handling payments via Stripe, or routing messages through Slack and Telegram, Nonhumans provides the identity, memory, wallet, and compute layer that your framework doesn’t. This page covers every supported integration, with working code examples for the most common patterns.

The Nonhumans models primitive gives your agent access to Anthropic, OpenAI, Google, Mistral, and more — all through a single API key. You don’t need separate accounts or environment variables for each LLM provider.

LLM providers

Nonhumans model access is a unified gateway to the leading LLM providers. Call any model without managing separate API keys:

Anthropic

Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku — ideal for reasoning and long-context tasks.

OpenAI

GPT-4o, GPT-4 Turbo, o1 — strong general-purpose and code generation models.

Google

Gemini 1.5 Pro and Flash — fast, multimodal, with a 1M-token context window.

Mistral

Mistral Large and Mixtral — efficient open-weight models for cost-sensitive workloads.

Hugging Face

Access thousands of open-source models via the Hugging Face Inference API.

OpenRouter

Route to the best available model automatically, with fallback and cost controls.

// Use any provider through the same interface
const response = await agent.models.chat({
  model: 'claude-3-5-sonnet',   // or 'gpt-4o', 'gemini-1.5-pro', etc.
  messages: [
    { role: 'user', content: 'Summarize this week's market news.' },
  ],
});

Framework integrations

LangChain

Expose your Nonhumans agent’s primitives as LangChain tools so any LangChain agent or chain can read email, check wallet balances, or store memories without leaving the LangChain ecosystem.

import { createAgent } from '@nonhumans/sdk';
import { NonhumansTool } from '@nonhumans/sdk/langchain';
import { ChatAnthropic } from '@langchain/anthropic';
import { AgentExecutor, createToolCallingAgent } from 'langchain/agents';
import { ChatPromptTemplate } from '@langchain/core/prompts';

const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });

// Wrap Nonhumans primitives as LangChain tools
const tools = [
  new NonhumansTool(agent.email, {
    name: 'read_inbox',
    description: 'Read unread emails from the agent inbox',
  }),
  new NonhumansTool(agent.wallet, {
    name: 'check_balance',
    description: 'Check the agent wallet balance',
  }),
  new NonhumansTool(agent.memory, {
    name: 'recall',
    description: 'Search agent memory for relevant past context',
  }),
];

const llm = new ChatAnthropic({ model: 'claude-3-5-sonnet-20241022' });

const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'You are a helpful AI agent with access to email, wallet, and memory tools.'],
  ['placeholder', '{chat_history}'],
  ['human', '{input}'],
  ['placeholder', '{agent_scratchpad}'],
]);

const langchainAgent = createToolCallingAgent({ llm, tools, prompt });
const executor = new AgentExecutor({ agent: langchainAgent, tools });

const result = await executor.invoke({
  input: 'Check my inbox and summarize any messages about invoices.',
});

console.log(result.output);

CrewAI

Use a Nonhumans agent as a specialized crew member in a CrewAI workflow. The agent brings its own identity, inbox, and wallet — while CrewAI handles task orchestration and inter-agent communication.

import { createAgent } from '@nonhumans/sdk';
import { NonhumansCrew } from '@nonhumans/sdk/crewai';
import { Crew, Task } from 'crewai';

const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });

// Wrap your Nonhumans agent as a CrewAI-compatible crew member
const emailAgent = new NonhumansCrew(agent, {
  role: 'Email Manager',
  goal: 'Monitor the inbox, triage messages, and draft replies',
  backstory: 'An AI agent with full email access and LLM reasoning capabilities.',
});

const triageTask = new Task({
  description: 'Read all unread emails and categorize them by urgency.',
  expectedOutput: 'A JSON list of messages with category and recommended action.',
  agent: emailAgent,
});

const crew = new Crew({
  agents: [emailAgent],
  tasks: [triageTask],
  verbose: true,
});

const result = await crew.kickoff();
console.log(result);

Blockchain and payments

Integration	What it enables	Status
Coinbase	On/off-ramp fiat ↔ crypto, custody, on-chain transfers	✅ Available
Stripe	Fiat payments, invoicing, virtual card issuance	✅ Available
Solana	Native USDC and SOL transfers, SPL tokens	✅ Available
Ethereum	ETH and ERC-20 transfers on mainnet and L2s	✅ Available
Lightning Network	Bitcoin micropayments	🔜 Coming soon

Messaging integrations

Your agent’s phone primitive powers messaging integrations. Use it to send and receive SMS, WhatsApp, and Telegram messages from your agent’s dedicated number.

Slack

import { createAgent } from '@nonhumans/sdk';
import { WebClient } from '@slack/web-api';

const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });
const slack = new WebClient(process.env.SLACK_BOT_TOKEN!);

// Example: agent posts a Slack alert when a high-priority email arrives
const messages = await agent.email.list({ folder: 'inbox', unread: true });

for (const message of messages) {
  if (message.subject.toLowerCase().includes('urgent')) {
    await slack.chat.postMessage({
      channel: '#alerts',
      text: `🚨 Urgent email from ${message.from}: "${message.subject}"`,
    });
  }
}

WhatsApp and Telegram

Send messages via your agent’s phone number primitive. WhatsApp Business API and Telegram Bot API are both supported:

// Send a WhatsApp message
await agent.phone.message.send({
  to: '+15551234567',
  body: 'Your order has shipped! Track it at: https://track.example.com/abc123',
  channel: 'whatsapp',
});

// Send a Telegram message
await agent.phone.message.send({
  to: '@username',
  body: 'Your report is ready. Reply with "download" to receive it.',
  channel: 'telegram',
});

Cloud hosting integrations

You can host your agent logic on any serverless platform and use Nonhumans purely as the identity and primitives layer. Deploy to Cloudflare Workers, Vercel Edge Functions, or AWS Lambda and call the Nonhumans SDK from your handler:

import { createAgent } from '@nonhumans/sdk';

export default {
  async fetch(request: Request): Promise<Response> {
    const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });

    const body = await request.json() as { message: string };

    const reply = await agent.models.chat({
      model: 'gpt-4o',
      messages: [{ role: 'user', content: body.message }],
    });

    return new Response(JSON.stringify({ reply: reply.content[0].text }), {
      headers: { 'Content-Type': 'application/json' },
    });
  },
};

import { createAgent } from '@nonhumans/sdk';
import { NextRequest, NextResponse } from 'next/server';

export const runtime = 'edge';

export async function POST(req: NextRequest) {
  const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });
  const { message } = await req.json();

  const reply = await agent.models.chat({
    model: 'claude-3-5-sonnet',
    messages: [{ role: 'user', content: message }],
  });

  return NextResponse.json({ reply: reply.content[0].text });
}

import { createAgent } from '@nonhumans/sdk';
import type { APIGatewayProxyHandler } from 'aws-lambda';

export const handler: APIGatewayProxyHandler = async (event) => {
  const agent = createAgent({ apiKey: process.env.NONHUMANS_API_KEY! });
  const { message } = JSON.parse(event.body ?? '{}');

  const reply = await agent.models.chat({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: message }],
  });

  return {
    statusCode: 200,
    body: JSON.stringify({ reply: reply.content[0].text }),
  };
};

When using Nonhumans’ built-in always-on compute (npx nonhumans deploy), you don’t need a separate cloud host at all. Use external cloud platforms when you need custom networking, VPCs, or existing infrastructure integrations.

Webhooks

Expose your agent as a public webhook endpoint so external services (Stripe, GitHub, Zapier, etc.) can trigger it on events:

// Register a webhook endpoint on your agent's subdomain
const endpoint = await agent.web.endpoint.register({
  path: '/stripe-webhook',
  events: ['invoice.paid', 'payment.failed'],
  secret: process.env.STRIPE_WEBHOOK_SECRET, // optional signature verification
});

console.log(`Webhook live at: ${endpoint.url}`);
// e.g. https://my-agent.nonhumans.ai/stripe-webhook

Your handler receives the raw POST body and headers, so you can verify signatures exactly as each provider’s documentation describes.

Full integration status

Integration	Category	Status
Anthropic (Claude)	LLM	✅ Available
OpenAI (GPT-4o, o1)	LLM	✅ Available
Google (Gemini)	LLM	✅ Available
Mistral	LLM	✅ Available
Hugging Face	LLM	✅ Available
OpenRouter	LLM router	✅ Available
LangChain	Framework	✅ Available
CrewAI	Framework	✅ Available
OpenAI Assistants API	Framework	✅ Available
Stripe	Payments	✅ Available
Coinbase	Crypto	✅ Available
Solana	Blockchain	✅ Available
Ethereum	Blockchain	✅ Available
Slack	Messaging	✅ Available
WhatsApp	Messaging	✅ Available
Telegram	Messaging	✅ Available
Cloudflare Workers	Hosting	✅ Available
Vercel Edge Functions	Hosting	✅ Available
AWS Lambda	Hosting	✅ Available
Zapier	Automation	✅ Available
Lightning Network	Crypto	🔜 Coming soon
Twilio (voice)	Voice	🔜 Coming soon
HubSpot	CRM	🔜 Coming soon
Salesforce	CRM	🔜 Coming soon

Don’t see an integration you need? Open a feature request or reach out at support@nonhumans.ai — community-requested integrations are prioritized.

​LLM providers

Anthropic

OpenAI

Google

Mistral

Hugging Face

OpenRouter

​Framework integrations

​LangChain

​CrewAI

​Blockchain and payments

​Messaging integrations

​Slack

​WhatsApp and Telegram

​Cloud hosting integrations

​Webhooks

​Full integration status

LLM providers

Framework integrations

LangChain

CrewAI

Blockchain and payments

Messaging integrations

Slack

WhatsApp and Telegram

Cloud hosting integrations

Webhooks

Full integration status