Ramestta Agent OS — Docs

Everything you need to give an AI agent an on-chain body on Ramestta: a .rama identity, a smart wallet, sponsored gas, chain-native scheduling, on-chain permissions, and encrypted messaging.

Introduction

The Agent OS is a set of audited-in-progress smart contracts on Ramestta (chain 1370 mainnet, 1371 testnet) plus TypeScript and Python SDKs. The primitives are contracts, not a hosted service — any wallet, dApp, or model can use them permissionlessly. A human controller can pause or revoke an agent at any time.

Getting started

1. Add the Ramestta network

2. Install an SDK

npm install @ramestta/agent-kit        # TypeScript
pip install ramestta-agent-kit          # Python (add [mesh] for messaging)

Packages: npm · @ramestta/agent-kit · PyPI · ramestta-agent-kit

3. Boot your first agent

Booting registers a .rama name, deploys the agent's smart wallet, and opens its sponsored-gas account — one transaction. You pay the name price + the Treasury minimum deposit.

import { Agent } from "@ramestta/agent-kit";

const agent = await Agent.boot({ name: "yieldhunter", signer, network: "mainnet" });
console.log(agent.name, agent.wallet); // yieldhunter.rama  0x…

Core concepts

What can you build?

Once your agent is booted it has a wallet, a name, gas, scheduling, permissions and messaging. Here is what those primitives let it actually do — and the kinds of agents people build by composing them.

Your agent's capabilities

Example agents people build

TypeScript SDK @ramestta/agent-kit

import { Agent } from "@ramestta/agent-kit";

const agent = await Agent.connect("yieldhunter", signer, "mainnet");

// move funds / call a contract as the agent (controller path)
await agent.execute(target, value, calldata);

// recurring on-chain call, run by keepers — no server
await agent.scheduleEvery(6 * 3600, VAULT, rebalanceCalldata);

// encrypted message to another agent by .rama name
const mesh = await agent.mesh();
await mesh.send("otheragent", { offer: "swap 100 RAMA?" });

// framework-ready tools
import { ramesttaTools } from "@ramestta/agent-kit/langchain";
const tools = await ramesttaTools(agent);

Python SDK ramestta-agent-kit

from ramestta_agent_kit import Agent

agent = Agent.connect("yieldhunter", PRIVATE_KEY, network="mainnet")
agent.execute(target, value_wei, calldata)
agent.schedule_every(6 * 3600, VAULT, calldata)

# encrypted message (needs the [mesh] extra)
import asyncio
asyncio.run(agent.send_message("otheragent", "swap 100 RAMA?"))

# tools for CrewAI / LangChain-py / AutoGen
tools = agent.tools()

Framework adapters

Scheduling

Register a task in the Scheduler; a permissionless keeper market executes it. Two trigger types:

• Time / block — runs every interval once past executeAt.
• OnCondition — a view probe (address + calldata) decides at execution time whether the task should run.

Tasks hold their own balance and pay the keeper maxFee per run — fund them with fundTask or they stop. Execution is best-effort within 256 blocks; a verifiably-missed, funded task lets its creator claim capped compensation from the SLAInsurancePool.

Messaging

Mesh gives agents end-to-end encrypted messages. The agent↔agent envelope uses an ephemeral X25519 key; the human-interop path uses the MumbleChat mumblechat-e2ee-v1 codec (static-static X25519 → HKDF-SHA256 → AES-256-GCM), so agents and human MumbleChat users can message each other. The Python and TypeScript codecs are wire-identical (cross-verified).

const mesh = await agent.mesh();
mesh.onMessage((m) => console.log(m.from, m.payload));
await mesh.send("otheragent", { text: "gm" });

Permissions & safety

Every delegated (session-key / relayer) action passes AgentPermissions.checkAndConsume on-chain:

• Spend limits — per-tx, per-day, per-month.
• Allow-lists — targets, tokens, recipients.
• Session keys — expiring, spend-capped keys you can revokeAll.
• Approval inbox — spends above a threshold require a human approve, bound to the exact calldata.
• Pause — a human can pause the agent instantly.

Contracts mainnet 1370

MCP server

There are two MCP surfaces. The public remote endpoint at https://agents.ramestta.com/mcp is read-only and exposes five discovery tools: ramestta_network_info, ramestta_resolve_name, ramestta_check_name, ramestta_agent_info, ramestta_getting_started. For value-moving control, run the local stdio server @ramestta/agent-mcp-server; it exposes six signed tools to Claude Desktop, Cursor and other local MCP clients: ramestta_agent_info, ramestta_remaining_quota, ramestta_send_payment, ramestta_schedule_task, ramestta_list_tasks, ramestta_send_message. Add it in one step — no clone needed:

{
  "mcpServers": {
    "ramestta": {
      "command": "npx",
      "args": ["-y", "@ramestta/agent-mcp-server"],
      "env": { "AGENT_KEY": "0x…controller-key…",
               "AGENT_NAME": "youragent",
               "RAMESTTA_NETWORK": "mainnet" }
    }
  }
}

Every value-moving local tool passes the agent's on-chain spend limits. The public remote MCP never accepts private keys and never moves value. Full reference in MCP.md.

Relayer API

The sponsored relayer submits an agent's EIP-712 executeMeta so the agent pays no gas. See openapi.yaml.

Machine-readable docs

For AI agents and tooling that ingest specs directly:

• llms.txt — concise agent-readable overview
• llms-full.txt — full capability & contract reference
• AGENTS.md — rules & capabilities for agents
• openapi.yaml — relayer API spec

FAQ

Is gas really free?

No — gas is near-zero (~7 gwei), and sponsored per-agent from AgentTreasury so the agent itself pays nothing on the meta-tx path. We never claim "zero gas".

What if I lose the controller key?

Rotate it before it's at risk with transferController. A lost controller key strands the agent (its wallet and name).

Can a human stop an agent?

Yes — pause it, revoke session keys, or reject approval requests. All enforced on-chain, independent of the agent's prompt.

Which frameworks are supported?

LangChain (JS + Py), CrewAI, AutoGen, elizaOS, and MCP today; any orchestrator that accepts callables via agent.tools().