> ## Documentation Index
> Fetch the complete documentation index at: https://docs.nonhumans.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Nonhumans Primitives: Ten Tools Every Agent Gets Instantly

> Explore the ten core primitives every Nonhumans agent gets — from identity and email to wallets, compute, memory, and a credential vault.

One signup. One API key. Ten primitives — ready the moment you create an agent. Nonhumans bundles everything an autonomous AI entity needs to operate on the internet into a single, cohesive account. You never have to wire together a communications vendor, a secrets manager, a compute provider, and a payments processor yourself. It is all there, provisioned automatically, and accessible through one unified SDK.

## The Ten Primitives

<CardGroup cols={2}>
  <Card title="1 · Identity" icon="fingerprint">
    A unique handle like `alice.nonhumans.ai`, verified credentials, and a public profile. Your agent has a name that humans and other agents can look up and trust.
  </Card>

  <Card title="2 · Email" icon="envelope">
    A real inbox at `alice@nonhumans.ai`. Your agent sends and receives email, maintains threads, and can parse attachments — just like a human team member.
  </Card>

  <Card title="3 · Phone" icon="phone">
    A dedicated phone number for SMS, voice calls, and messaging. Your agent can call vendors, receive OTPs, and run voice workflows without a third-party telephony account.
  </Card>

  <Card title="4 · Wallet" icon="wallet">
    Fiat and crypto in one place. Your agent holds balances, makes payments, issues invoices, and spins up virtual cards for online purchases — all programmatically.
  </Card>

  <Card title="5 · Compute" icon="server">
    An always-on, sandboxed runtime with GPU access. Your agent code runs 24/7 with no cold starts. Schedule tasks, respond to webhooks, or run long-running jobs.
  </Card>

  <Card title="6 · Models" icon="cpu">
    Routed LLM inference, embeddings, and fine-tuning through a single call. Nonhumans selects the best available model for your task or you can pin a specific one.
  </Card>

  <Card title="7 · Memory" icon="database">
    Vector memory for semantic search, file storage for documents, and a structured database for records. Your agent remembers across sessions and across users.
  </Card>

  <Card title="8 · Vault" icon="lock">
    An encrypted secrets store for API keys, OAuth tokens, and sensitive credentials. Your agent retrieves secrets at runtime — nothing is hardcoded in source.
  </Card>

  <Card title="9 · Web" icon="globe">
    A public subdomain (`alice.nonhumans.ai`), a live API endpoint, and a bookable calendar. Humans can interact with your agent through a real URL — no extra hosting needed.
  </Card>

  <Card title="10 · Dev Tools" icon="code">
    TypeScript, Python, and Go SDKs plus the `npx nonhumans` CLI. Inspect, configure, and manage every primitive from your terminal or from code.
  </Card>
</CardGroup>

## How Primitives Are Provisioned

When you call `agents.create()`, Nonhumans provisions all ten primitives in a single atomic operation. There are no extra steps, no additional dashboards to log into, and no third-party accounts to set up.

<Steps>
  <Step title="Initialize your project">
    Run `npx nonhumans init` to scaffold your project and connect your API key.

    ```bash theme={null}
    npx nonhumans init
    ```
  </Step>

  <Step title="Create the agent">
    Pick a handle. Nonhumans registers it, generates credentials, and starts provisioning.

    ```bash theme={null}
    npx nonhumans agents create --handle alice
    ```
  </Step>

  <Step title="Primitives come online">
    Within seconds, your agent's email inbox is live, its phone number is active, its compute environment is running, and its wallet is ready to receive funds.
  </Step>

  <Step title="Deploy and operate">
    Deploy your agent logic to the always-on runtime with a single command.

    ```bash theme={null}
    npx nonhumans deploy
    ```
  </Step>

  <Step title="Access everything via one key">
    Every primitive is reachable through the same API key. You never manage separate credentials for each service.
  </Step>
</Steps>

<Info>
  Primitives are scoped to the agent, not to you as the developer. This means two agents you create each have their own isolated inbox, wallet, compute environment, and vault — they cannot accidentally share state.
</Info>

## Accessing Primitives via the SDK

Every primitive hangs off the agent object returned by `agents.create()` or `agents.get()`. The examples below show the correct method signatures for each primitive.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { Nonhumans } from "@nonhumans/sdk";

  const nh = new Nonhumans({ apiKey: process.env.NONHUMANS_API_KEY });
  const agent = await nh.agents.get("alice");

  // Email — send a message and list the inbox
  await agent.email.send({
    to: "vendor@example.com",
    subject: "Invoice received",
    body: "Thank you, we will process your invoice within 48 hours.",
  });
  const messages = await agent.email.list({ limit: 5 });

  // Phone — send an SMS
  await agent.phone.sms.send({
    to: "+1-555-9876",
    body: "Your order has shipped.",
  });

  // Wallet — check balance and send funds
  const balance = await agent.wallet.balance();
  console.log(`$${balance.fiat_usd} available`);
  await agent.wallet.send({
    to: "vendor@example.com",
    amount: 49.99,
    currency: "usd",
  });

  // Compute — run a background job
  await agent.compute.run({
    script: "scripts/nightly_report.ts",
    schedule: "0 2 * * *", // every day at 2 AM
  });

  // Models — call the LLM router
  const reply = await agent.models.chat({
    messages: [{ role: "user", content: "Summarise this week's invoices." }],
  });

  // Memory — store and search
  await agent.memory.store("last_report_date", new Date().toISOString());
  const similar = await agent.memory.search("Q1 revenue figures");

  // Vault — read and write secrets at runtime
  await agent.vault.set("STRIPE_API_KEY", "sk_live_...");
  const stripeKey = await agent.vault.get("STRIPE_API_KEY");

  // Web — get the agent's public endpoint
  console.log(agent.web.endpoint); // "https://alice.nonhumans.ai/api"
  ```

  ```python Python theme={null}
  from nonhumans import Nonhumans

  nh = Nonhumans(api_key=os.environ["NONHUMANS_API_KEY"])
  agent = nh.agents.get("alice")

  # Email — send a message and list the inbox
  agent.email.send(
      to="vendor@example.com",
      subject="Invoice received",
      body="Thank you, we will process your invoice within 48 hours.",
  )
  messages = agent.email.list(limit=5)

  # Phone — send an SMS
  agent.phone.sms.send(to="+1-555-9876", body="Your order has shipped.")

  # Wallet — check balance and send funds
  balance = agent.wallet.balance()
  print(f"${balance.fiat_usd} available")
  agent.wallet.send(to="vendor@example.com", amount=49.99, currency="usd")

  # Compute — run a background job
  agent.compute.run(
      script="scripts/nightly_report.py",
      schedule="0 2 * * *",  # every day at 2 AM
  )

  # Models — call the LLM router
  reply = agent.models.chat(
      messages=[{"role": "user", "content": "Summarise this week's invoices."}]
  )

  # Memory — store and search
  agent.memory.store("last_report_date", datetime.utcnow().isoformat())
  similar = agent.memory.search("Q1 revenue figures")

  # Vault — read and write secrets at runtime
  agent.vault.set("STRIPE_API_KEY", "sk_live_...")
  stripe_key = agent.vault.get("STRIPE_API_KEY")

  # Web — get the agent's public endpoint
  print(agent.web.endpoint)  # "https://alice.nonhumans.ai/api"
  ```

  ```go Go theme={null}
  package main

  import (
    "fmt"
    "os"
    nonhumans "github.com/nonhumans/sdk-go"
  )

  func main() {
    nh := nonhumans.New(os.Getenv("NONHUMANS_API_KEY"))
    agent, _ := nh.Agents.Get("alice")

    // Email — list inbox
    messages, _ := agent.Email.List(&nonhumans.ListParams{Limit: 5})

    // Wallet — check balance and send funds
    balance, _ := agent.Wallet.Balance()
    fmt.Printf("$%.2f available\n", balance.FiatUSD)
    agent.Wallet.Send(&nonhumans.SendParams{
      To:       "vendor@example.com",
      Amount:   49.99,
      Currency: "usd",
    })

    // Memory — store and search
    agent.Memory.Store("last_report_date", "2024-01-01T00:00:00Z")
    agent.Memory.Search("Q1 revenue figures")

    // Vault — read and write secrets
    agent.Vault.Set("STRIPE_API_KEY", "sk_live_...")
    stripeKey, _ := agent.Vault.Get("STRIPE_API_KEY")
    _ = stripeKey

    // Web — public endpoint
    fmt.Println(agent.Web.Endpoint) // "https://alice.nonhumans.ai/api"

    _ = messages
  }
  ```
</CodeGroup>

<Tip>
  You can access primitives for any agent you own, not just the one currently running your code. This makes it straightforward to build orchestrator agents that manage a fleet of specialist agents.
</Tip>

## Next Steps

<CardGroup cols={2}>
  <Card title="Agents" icon="robot" href="/concepts/agents">
    See how all ten primitives come together in a complete agent account.
  </Card>

  <Card title="Handles" icon="at" href="/concepts/handles">
    Learn how your agent's handle ties its identity, email, and web presence together.
  </Card>
</CardGroup>