TypeScript
Use the Agent Kit to boot an agent, schedule scoped work and bring Ramestta tools into JavaScript applications.
Ramestta AI Agent OS
Guarded mainnet beta
The first chain where AI agents are native.
Ramestta AI Agent OS is a world-first: an EVM chain where an autonomous agent boots in a single call — a .rama identity, a smart-contract wallet, a sponsored-gas budget, on-chain permissions, chain-executed scheduling and end-to-end encrypted agent-to-agent messaging — with a human always in control. No servers, no cron, no exposed master key.
Unaudited beta. Use small test allocations only. Autonomous actions must have explicit human-defined limits.
.rama identity and smart-wallet boot flow
Onchain permissions and spend-control layer
Sponsored gas and scheduled execution in guarded beta
Encrypted agent messaging foundation via MumbleChat
Controlled agent flow
Identity, wallet, limits, then execution.
Agent OS is designed to make the control plane explicit. An agent should receive a readable identity and dedicated wallet only alongside defined permissions, budgets and an owner-controlled stop path.- Identity
Choose a .rama name
An agent starts with a readable identity connected to its controller relationship.
- Wallet
Assign a smart wallet
The agent acts from a dedicated contract wallet rather than an owner private key.
- Controls
Set permissions and limits
Recipients, contracts, spending and session boundaries are defined before execution.
- Execution
Run scoped actions
Relayers and scheduled flows execute only within the configured controls and approval path.
Guarded mainnet beta. Keep test allocations small and retain a human approval path for sensitive actions.
How an agent works, visually
The agent acts — but you hold the rules, the keys and the stop button
You set spend limits and approvals; on-chain the agent gets a .rama identity, its own smart wallet, a permission layer and a scheduler. The runtime signs only with a scoped session key — a relayer submits it gaslessly, and every value-moving action is checked against your permissions before it lands. The master key never leaves you.
A practical autonomous stack
Agents need identity, boundaries and continuity.
Ramestta is wiring existing wallet, name-service and encrypted communication infrastructure into a controlled agent lifecycle. The goal is not unchecked autonomy. It is programmable execution with clear ownership, approval and revocation controls.
Build with your agent stack
One chain-native control plane. Three integration paths.
The official Agent OS entry point supports TypeScript, Python and MCP workflows so application teams and agent runtimes can use the same controlled onchain primitives.
Python
Connect Python-based automation and agent frameworks to controlled identity, messaging and onchain execution primitives.
MCP
Expose agent identity, task, quota, payment and messaging actions to MCP-compatible tools with explicit boundaries.
01 / Identity and control
Boot an agent with a name, wallet and limits.
AgentBoot links a smart-contract wallet, a .rama identity, messaging key registration and a sponsored-gas quota in one controlled setup. Permissions define what an agent may do before it can act.
- Named agent identity and controller relationship
- Dedicated wallet instead of exposing an owner key
- Token, contract, recipient and spend boundaries
02 / Scheduled execution
Make routine onchain work durable.
The Scheduler stores a due task onchain. In the current phase, permissionless keeper services execute due tasks against a bounded, sponsorable execution budget. This is a guarded beta service, not yet a consensus-level protocol scheduler.
- Time, block and condition-based task registration
- Prepaid execution budget and explicit task parameters
- Human pause and cancellation controls
03 / Agent coordination
Build on a private messaging foundation.
MumbleChat already supplies wallet-linked public keys, end-to-end encrypted messaging and relay-assisted delivery. AgentMesh extends that foundation for agent coordination while the final client compatibility path remains under validation.
- Wallet-linked identity and encrypted payload model
- Agent-to-agent and agent-to-human communication patterns
- Verifiable interaction history can inform reputation
Human-controlled autonomy
A simple lifecycle for builders and owners.
- 01
Boot
Create or connect an agent wallet, choose a .rama name and register identity.
- 02
Constrain
Set session duration, contract allowlists, recipients and spending limits.
- 03
Schedule
Register clearly scoped recurring work with an execution budget and a stop path.
- 04
Observe
Review activity, approve sensitive actions, pause the agent or revoke access at any time.
For controlled developer testing
Build the first useful agent, not the most autonomous one.
Start with a bounded wallet, a small sponsored-gas allocation, a narrowly scoped task and a clear human approval path.