An Introduction to Sutra.team: The First OS for Autonomous Agents

Sutra.team is an operating system specifically engineered for AI agents, designed to move beyond traditional chat interfaces and deploy autonomous specialists capable of running continuously without human prompting. Unlike many agent frameworks that often necessitate constant human oversight, Sutra.team provides robust, opinionated infrastructure tailored for production deployment. This powerful platform features three interconnected core layers: KARMA for comprehensive cost governance, SILA for immutable audit compliance, and SUTRA for sophisticated multi-agent orchestration. Built by the visionary JB Wagoner, Sutra.team seamlessly integrates with over 32 OpenClaw skills, encompassing essential functionalities like browser automation, email handling, and advanced council deliberation. It also offers broad support for Bring Your Own Key (BYOK) for leading large language models such as Claude, GPT-4, Gemini, and even local models. Priced affordably at $9/month for the Explorer tier, users gain access to critical features including heartbeat scheduling, Portable Mind Format exports for true ownership, and flexible deployment options to popular platforms like Telegram, Slack, and email. This comprehensive guide will meticulously walk you through the process of constructing and deploying your very first unsupervised agent using Sutra.team.

What You’ll Accomplish in This Guide

By the culmination of this detailed walkthrough, you will have successfully deployed a fully autonomous financial monitoring specialist. This agent will operate independently, executing daily market analysis without any human intervention. Your agent will be configured to activate precisely at 09:00 UTC through Sutra.team’s integrated heartbeat scheduling system. Upon activation, it will leverage OpenClaw’s browser automation skills to query real-time cryptocurrency prices from various sources. Subsequently, it will perform advanced sentiment analysis on breaking news headlines, gathered via web search, to gauge market mood. Finally, it will compile its findings into a clear, formatted report and deliver it directly to your designated Slack workspace.

A crucial aspect of this deployment will be the implementation of KARMA cost governance, which will enforce a strict daily API spending limit of $5.00, effectively preventing the common issue of runaway token consumption that often plagues other autonomous systems. You will also configure SILA audit trails to meticulously capture every data access and decision point, ensuring cryptographic hashes are generated for robust SOC2 compliance. Furthermore, you will set up Council deliberation, an advanced feature that allows your agent to handle ambiguous trading signals by invoking eight specialist perspectives, ensuring well-rounded analysis before any action is taken. The final step involves exporting your entire agent configuration as a Portable Mind JSON file, a process that unequivocally demonstrates true ownership and unparalleled portability of your AI asset. This entire setup represents production-grade infrastructure, far beyond a mere prototype. Your deployed agent will exhibit resilience, surviving server restarts, gracefully handling API rate limits, and maintaining immutable logs of every decision made. The estimated cost for this entire endeavor will be approximately $9 for the Explorer tier subscription, plus an additional $0.50 in API costs for the LLM and other services.

Prerequisites: Hardware, Software, and API Keys for Sutra.team

To successfully follow this guide and deploy your autonomous agent with Sutra.team, you will need a capable computing environment. Your machine should be running macOS 14+ (Sonoma or newer), Ubuntu 22.04 LTS, or Windows 11 with Windows Subsystem for Linux 2 (WSL2) enabled. For memory, allocate a minimum of 8GB RAM, though 16GB is highly recommended, especially if you plan on running local Large Language Models (LLMs) via Ollama. Ensure you have at least 20GB of free disk space to accommodate Docker images and persistent log storage.

Begin by signing up at sutra.team/pricing for the $9 per month Explorer tier, which grants you unlimited agent deployments and full platform access. After signing up, verify your email address and generate an API key from your Sutra.team dashboard. Next, prepare your Bring Your Own Key (BYOK) credentials for your preferred LLM providers. This includes an Anthropic API key (typically starting with sk-ant-api), an OpenAI key (starting with sk-proj), or configuring a local endpoint such as http://localhost:11434 for Ollama integration. Install Node.js version 20.11.0 or any newer LTS release. Install Docker Desktop version 4.26 or newer and ensure the Docker daemon is actively running in the background. For integration testing, you will need a Telegram Bot Token obtained from @BotFather within Telegram, and a Slack Incoming Webhook URL configured for your desired Slack workspace. If you intend to utilize custom skills beyond the default 32 provided by OpenClaw, ensure you have your OpenClaw registry credentials ready. Finally, it is imperative that your system clock is accurately synchronized via Network Time Protocol (NTP), as Sutra.team’s heartbeat scheduling mechanism relies heavily on precise timestamps for cron execution.

Step 1: Installing the Sutra CLI and Authenticating Your Environment

The first practical step in deploying your autonomous agent with Sutra.team involves setting up the command-line interface (CLI). Open your preferred terminal application and execute the following command to install the Sutra CLI globally:

npm install -g @sutra/team-cli@latest

After the installation completes, verify that the CLI has been installed correctly by running sutra --version. You should see a version number of 2.4.1 or higher displayed in your terminal. Next, you need to authenticate the CLI with your Sutra.team account. Run sutra login and, when prompted, paste your API key that you generated from the Sutra.team dashboard. The CLI securely stores your authentication tokens in a file located at ~/.sutra/credentials.json, ensuring it has strict 0600 file permissions, meaning only your user account can read this sensitive file.

To confirm successful connectivity to the Sutra.team orchestration layer, execute sutra ping. You should anticipate a response time typically ranging between 40 and 60 milliseconds, indicating a healthy connection. If your operating environment is behind a corporate proxy, it is essential to export the HTTPS_PROXY and HTTP_PROXY environment variables before attempting the login process. On Linux systems, the Sutra CLI generally requires sudo access only for the initial configuration step involving the Docker socket. Windows users, however, must launch PowerShell as an Administrator for the first-time setup to ensure the necessary registry entries are created correctly. Once authenticated, you can initialize your first project by running sutra init crypto-sentinel. This command will create a new directory named crypto-sentinel in your current working directory, which will contain the standard project folder structure: config/, skills/, and logs/. Navigate into this newly created directory and list its contents to confirm that the scaffolding process was successful.

Step 2: Understanding the Three-Layer Architecture: KARMA, SILA, SUTRA

Before you begin configuring individual files, it is paramount to grasp the foundational three-layer architecture that underpins Sutra.team. This architectural design distinctly separates concerns, providing a robust and manageable system for autonomous agents.

At the highest level, KARMA functions as the governance layer. Its primary responsibility is to meticulously track every single skill invocation against your predefined budget in real-time. This ensures that your agent operates within financial constraints, preventing unexpected costs. Below KARMA, the SILA layer handles audit compliance. It cryptographically logs every data access event and external API call, appending immutable hashes to each entry, thereby providing an unalterable chain of custody for compliance purposes. Finally, SUTRA operates as the central orchestration engine. This layer manages the agent’s event loop, oversees heartbeat scheduling for proactive task execution, and orchestrates complex multi-agent workflows, including council deliberation.

Consider their interrelationship: SUTRA is the brain, deciding what actions to take based on your agent’s mandate and current events. KARMA acts as the financial controller, determining whether those proposed actions are within budget. SILA serves as the meticulous record-keeper, documenting every action for transparency and accountability. This clear separation of concerns is vital because it prevents scenarios where an agent could operate autonomously and inadvertently generate hundreds or thousands of dollars in unexpected API charges. Each of these layers is configurable through dedicated YAML files located in your project’s config/ directory. You will define spending caps in karma.yaml, specify data retention and hashing policies in sila.yaml, and establish multi-agent coordination rules within sutra.yaml. Understanding this modularity is crucial as it allows you to independently modify cost controls without altering the agent’s core business logic, or update audit settings without disrupting its orchestration.

Feature	Traditional Chatbot	Sutra.team Agent
Trigger Mechanism	Human prompt, manual input	Heartbeat schedule, event-driven
Cost Control	Generally none, ad-hoc	KARMA real-time budgets, throttling
Audit & Compliance	Optional, often manual	SILA mandatory cryptographic hashes, retention
Deployment Model	Manual, user-initiated	Autonomous, 24/7, self-recovering
Failure Mode	Silent stop, crash	Graceful throttle, alert, retry mechanisms
Decision Making	Direct LLM output	LLM output + Council deliberation (multi-persp.)
Portability	Code/config files	Portable Mind JSON (full state)
External Integrations	Ad-hoc, custom code	Standardized OpenClaw skills, Dockerized

Step 3: Creating Your First Specialist Agent Configuration

Now that you understand the architectural foundation, let’s define your agent. Navigate to your project directory, which you created with sutra init crypto-sentinel, and open the agent.yaml file in your preferred text editor (e.g., VS Code, Sublime Text, Vim).

Within this file, you will configure the core identity and mandate of your autonomous specialist. Set the name field to “CryptoSentinel” to clearly identify your agent. Assign its specialization to “financial_analysis”, indicating its primary domain of expertise. Most importantly, craft a precise and unambiguous mandate that outlines its operational goals. For this guide, use: “Monitor Bitcoin and Ethereum prices daily at 09:00 UTC; if volatility exceeds 5% in 24 hours, perform sentiment analysis on top 10 news articles; report findings to Slack channel #alerts”. This clear mandate is critical for the agent’s planning engine.

To ensure your agent operates without requiring human confirmation for every step, set autonomy_level to “full” instead of “assisted”. This enables proactive execution based on its mandate. Configure the heartbeat schedule using standard cron syntax: schedule: "0 9 * * *" and specify timezone: "UTC". This configuration ensures your agent independently wakes itself up every day at 09:00 UTC, regardless of external triggers. To enhance resilience, add retry_policy settings with max_attempts: 3 and backoff_strategy: "exponential". This instructs the agent to retry failed operations up to three times, with increasing delays between attempts, effectively handling transient network issues or temporary API unavailability.

After saving the agent.yaml file, run sutra validate in your terminal. This command performs a crucial check for YAML syntax errors and, more importantly, assesses the logical consistency of your configuration. The validator ensures that your mandate is sufficiently specific for the agent’s planning engine to generate a coherent and actionable task graph. Vague mandates, such as “watch markets,” would typically fail validation with an error code like E042, prompting you to refine its instructions. This specificity is a cornerstone of achieving true and reliable autonomy.

Step 4: Importing OpenClaw Skills into Your Agent for Enhanced Capabilities

Sutra.team provides a robust ecosystem of over 32 pre-audited OpenClaw skills, but for security and efficiency, you must explicitly declare which ones your agent is permitted to invoke. This granular control ensures your agent only has access to the tools it truly needs for its specific mandate.

Open the skills.yaml file within your project directory. Within this file, you will list the OpenClaw skills necessary for your CryptoSentinel agent. Add the following imports, specifying their respective versions to ensure compatibility and stability:

• openclaw/web_search at version 2.1.0
• openclaw/browser_automation at version 2.1.0
• openclaw/sentiment_analysis at version 1.8.0
• openclaw/slack_notification at version 2.0.0

After adding these entries, execute sutra skills install in your terminal. This command will pull these containerized skills from the secure OpenClaw registry and make them available to your agent. A significant security feature of Sutra.team is that each skill executes within its own isolated Docker container, complete with strict network policies. For instance, the web_search skill will be granted limited internet access to perform its function, while the sentiment_analysis skill might run in an air-gapped environment with no outbound connections, minimizing data exfiltration risks.

To verify that all skills have been successfully installed and are ready for use, run sutra skills list. You should observe four green checkmarks next to the listed skills, indicating their healthy status. If your project requires functionalities beyond the standard OpenClaw library, you can integrate custom skills. To do this, use the command sutra skills add --from-git https://github.com/yourorg/custom-skill.git, replacing the URL with your Git repository. Custom skills undergo a rigorous process of static analysis and sandbox testing before they are permitted to execute, further enhancing the platform’s security posture against potential supply chain attacks. All installed skills are stored locally in ~/.sutra/skills/ and are mounted read-only into the agent containers at runtime, ensuring their integrity.

Step 5: Setting Up BYOK with Claude, GPT-4, or Local Models

Sutra.team’s Bring Your Own Key (BYOK) approach is a cornerstone of its design, ensuring you retain full control over your LLM API usage and associated costs. To manage your sensitive credentials securely, create a file named .env in the root of your project directory. This file will store your API keys as environment variables, preventing them from being hardcoded directly into your configuration files.

For Anthropic’s Claude models, add your API key in the format:

ANTHROPIC_API_KEY=sk-ant-api03-...

If you prefer OpenAI’s GPT-4, use:

OPENAI_API_KEY=sk-proj-...

For those opting for local model deployment via Ollama or LM Studio, configure the endpoint and model name:

LOCAL_MODEL_URL=http://localhost:11434/v1
LOCAL_MODEL_NAME=llama3.2:8b

After defining your API keys, inform Sutra.team which provider and model to use by executing the following command. For example, to use Claude 3.5 Sonnet:

sutra config:set provider=anthropic model=claude-3-5-sonnet-20241022

A key advantage of Sutra.team is that it acts purely as a router, not a proxy. This means your API calls travel directly from your infrastructure to the respective LLM provider’s servers (e.g., Anthropic’s endpoints) without ever transiting through Sutra.team’s own systems. Your API keys are encrypted at rest using strong AES-256 encryption and are never exposed in logs, providing a high level of security.

To test your LLM configuration and ensure everything is set up correctly, run sutra test:llm. This command sends a small, sample prompt to your configured LLM and reports the response and latency. You can expect typical latencies of approximately 800 milliseconds for cloud-based models like Claude 3.5 Sonnet, or around 2000 milliseconds for local Llama models running on Ollama. If you are using Ollama, confirm that the server is running by executing ollama serve before attempting to start your agent. Sutra.team also supports overriding model parameters like temperature and max_tokens directly via command-line flags, offering fine-grained control over your agent’s creative and verbosity settings.

Step 6: Defining Heartbeat Schedules for Proactive Operation

A fundamental characteristic of truly autonomous agents is their ability to initiate tasks proactively, without needing constant human intervention or manual cron jobs. Sutra.team achieves this through its robust heartbeat scheduling mechanism.

Within your agent.yaml file, locate or create the heartbeat section. To enable this feature, set enabled: true. For a daily operation, you might specify interval: "24h". However, for more precise scheduling, especially for a financial monitoring agent, using cron syntax is more effective. For example, cron: "0 9 * * 1-5" will instruct your agent to activate at 09:00 UTC on weekdays (Monday through Friday), skipping weekends. The heartbeat scheduler operates using UTC timestamps by default, ensuring consistency across different geographical locations. Crucially, its state persists across server restarts by storing necessary information in a local SQLite database, typically found at ~/.sutra/heartbeat.db.

To further enhance the agent’s reliability, configure a retry_policy within the heartbeat settings. Set max_attempts: 3 and backoff: "exponential" starting at 5 seconds. This configuration ensures that if a scheduled heartbeat fails due to temporary issues like network outages or API downtime, the system will automatically retry the execution up to three times, with increasing delays to allow for recovery. Should a heartbeat fail for three consecutive attempts, SUTRA will intelligently mark the agent as “stalled” and automatically dispatch an alert to your configured notification channel, allowing for prompt human intervention.

To test your configured schedule without triggering any actual API calls or notifications, run sutra heartbeat:test. This command simulates the next scheduled execution, providing valuable feedback. Check the output to confirm that your agent correctly initializes its skill set and validates its configuration files. The heartbeat system is a critical component that effectively prevents the “chatbot amnesia” problem, where agents lose their context or purpose between interactions. By maintaining continuous mandate continuity, your Sutra.team agent remains consistently aware of its objectives.

Step 7: Configuring Cost Governance with KARMA Budgets

One of the most significant challenges in deploying autonomous AI agents is managing unpredictable API costs. Sutra.team addresses this head-on with KARMA, its sophisticated cost governance layer. To implement stringent financial controls, open the karma.yaml file in your project directory.

Within this file, you will define hard limits for your agent’s spending. Set daily_budget_usd: 5.00 and monthly_budget_usd: 50.00 to establish clear boundaries and prevent any unexpected expenditures. KARMA doesn’t just track overall spending; it allows for granular control over individual skill usage. Configure per_skill_limits to allocate specific budgets to different operations. For example, you might set web_search at $0.01 per invocation, sentiment_analysis at $0.005, and slack_notification at $0.001. KARMA tracks token usage in real-time, leveraging libraries like tiktoken for highly accurate cost estimation.

When your agent consumes 80% of its allotted daily budget, KARMA intelligently switches it into “throttle mode.” In this mode, the agent automatically prioritizes cheaper model tiers, reduces the depth of web searches, or intelligently adjusts other parameters to conserve budget. If the agent reaches 100% budget consumption, KARMA will pause non-critical skills, ensuring that essential functions like heartbeat checks continue to maintain the agent’s presence and monitoring capabilities.

You can monitor your agent’s current spending at any time using sutra karma:status. This command displays the remaining budget, a projected monthly spend based on current velocity, and a detailed cost breakdown by skill. For accounting and reporting purposes, you can export detailed reports using sutra karma:export --format csv --last 30 days. KARMA also incorporates an anomaly detection system. If your agent suddenly exhibits spending patterns that are, for instance, 10 times its normal rate, it triggers an automatic circuit breaker, temporarily halting operations and notifying you via email to investigate the cause.

Step 8: Enabling SILA Audit Trails for Compliance

In today’s regulatory landscape, robust auditing and compliance are not optional, especially for autonomous systems handling sensitive data. Sutra.team’s SILA layer provides comprehensive, cryptographically verifiable audit trails. To configure these essential features, open the sila.yaml file in your project directory.

Within sila.yaml, you will define your data retention policies. For example, setting retention_days: 2555 ensures that your records are kept for seven years, a common requirement in financial regulations. To guarantee the integrity and immutability of your logs, enable hash_verification: true. This setting appends SHA-256 hashes to each log entry, creating a tamper-proof, cryptographically verifiable chain of custody. SILA meticulously logs every skill invocation, capturing a wealth of contextual information: a precise timestamp (with millisecond accuracy), input parameters (which are automatically sanitized of Personally Identifiable Information, or PII), output summaries, and crucial data classification tags. These tags can mark fields as financial, personal, or public, aiding in compliance efforts.

The logs are written to an append-only SQLite database located at ~/.sutra/logs/. For enhanced durability and off-site backup, this local database syncs hourly to your configured S3 bucket, if one is specified. To verify the integrity of your audit logs and detect any potential tampering, simply run sutra sila:verify. For organizations needing to comply with regulations like GDPR, enable auto_redact_pii: true. This feature automatically masks sensitive information such as email addresses and phone numbers using predefined regex patterns, reducing compliance burden. When it comes time for external audits, you can generate comprehensive compliance reports using sutra sila:report --standard SOC2 --start-date 2026-01-01 --output-format pdf. This allows auditors to verify the entire operational chain without needing access to your confidential API keys or raw data stores, streamlining the audit process and ensuring transparency.

Step 9: Implementing Council Deliberation for Complex Decisions

Autonomous agents, especially those operating in dynamic and ambiguous environments like financial markets, benefit immensely from multi-perspective analysis. Sutra.team’s Council deliberation skill provides a structured way for your agent to address complex decisions and mitigate the risks of single-model hallucinations.

To enable this advanced feature, open your sutra.yaml file. Within this configuration, set council_deliberation: true and define an uncertainty_threshold, for example, uncertainty_threshold: 0.3. The Council skill, an integral part of OpenClaw, invokes eight specialist agents, each representing a distinct perspective inspired by established decision-making frameworks. These perspectives include:

• Right View: Focuses on verifying data accuracy and factual correctness.
• Right Intention: Checks for inherent biases and ensures alignment with the agent’s core purpose.
• Right Speech: Evaluates the safety and clarity of proposed outputs.
• Right Action: Validates ethical constraints and adherence to established guidelines.
• Right Livelihood: Confirms the business alignment and value proposition of the decision.
• Right Effort: Optimizes resource usage and efficiency.
• Right Mindfulness: Maintains contextual awareness and prevents narrow focus.
• Right Concentration: Ensures sustained focus on the core problem without distraction.

You can configure the voting_mode to “weighted_confidence” rather than a simple majority. This means that responses from perspectives with higher certainty scores will carry more weight in the final consensus. In your agent’s logic, you would trigger this deliberation when faced with ambiguity, for instance, if sentiment analysis results are conflicting or market signals are unclear. The invocation might look like this:

decision:
  invoke: council.deliberate
  inputs:
    query: "Should we alert on 4.8% volatility?"
    context: "{{ market_data }}"
    perspectives: ["right_view", "right_intention", "right_action"] # You can specify specific perspectives

The Council will then return a consensus score, typically between 0 and 1, indicating the collective confidence in a particular course of action, along with any dissenting notes from minority perspectives. Critically, the full deliberation process, including all perspectives and their rationales, is logged to SILA, providing a comprehensive audit trail for review. This multi-perspective approach is a powerful safeguard, preventing any single-model hallucination or biased interpretation from driving autonomous actions.

Step 10: Deploying to Telegram, Slack, and Email Channels

Connecting your autonomous agent to various communication channels is essential for receiving alerts, reports, and interacting with its output. Sutra.team provides flexible configuration options for deploying to popular platforms like Telegram, Slack, and email. To set up these deployment targets, open the deployment.yaml file in your project directory.

For Telegram integration, you will need your Telegram Bot Token and the chat ID where you want the messages to be sent. Configure it as follows:

telegram:
  bot_token: "${TELEGRAM_TOKEN}" # Environment variable for security
  chat_id: "${CHAT_ID}"         # Environment variable for security
  format: "markdown"            # Use markdown for rich text formatting
  disable_notification: false   # Set to true to send silent notifications

For Slack, you will need the Incoming Webhook URL you generated in your Slack workspace:

slack:
  webhook_url: "${SLACK_WEBHOOK}" # Environment variable for security
  channel: "#crypto-alerts"     # The Slack channel to post to
  username: "CryptoSentinel"    # Custom username for the bot
  mention_on_critical: "@here"  # Mention @here on critical alerts

For email alerts, assuming you have an SMTP server (like Gmail’s SMTP service), configure it like this:

email:
  smtp_host: "smtp.gmail.com"
  smtp_port: 587
  username: "${EMAIL_USER}"     # Environment variable for security
  password: "${EMAIL_PASS}"     # Environment variable for security
  to: "ops@yourcompany.com"     # Recipient email address
  subject_template: "Daily Crypto Report: {{date}}" # Dynamic subject line

After configuring your desired channels, initiate the deployment by running sutra deploy --target telegram --target slack (or include --target email if configured). This command registers the necessary webhooks and schedules the agent’s first heartbeat. Verify the deployment status by running sutra status. You should see “RUNNING” as the status, along with a next_execution timestamp indicating when the agent is scheduled to run next (typically within 24 hours). To perform an immediate test and confirm message delivery to all configured channels, trigger a manual execution with sutra trigger:manual. This allows you to check the formatting of messages in each client (Telegram, Slack, email) to ensure markdown or other rich text renders correctly. This step is crucial for confirming that your autonomous agent can effectively communicate its findings and alerts.

Step 11: Testing Autonomous Operation End-to-End

The true test of an autonomous agent lies in its ability to operate reliably and unsupervised in a production environment. After deployment, allow your CryptoSentinel agent to run independently for at least 24 hours to validate its behavior under real-world conditions.

Throughout this period, closely monitor its performance and resource consumption. Use sutra karma:status --watch to continuously observe its spending habits. This real-time monitoring is critical for detecting any runaway costs immediately, well before they exceed your $5 daily budget. To gain insights into its decision-making process without interrupting its execution, stream the agent’s logs using sutra logs --follow --level info. This command allows you to see its internal thought processes and actions as they unfold.

Verify the agent’s resilience by observing how it handles common failure scenarios. For instance, confirm that when the web_search skill encounters a 429 (Too Many Requests) error, the agent automatically implements an exponential backoff strategy, waiting for a specified period (e.g., 60 seconds) before retrying. Test its behavior during temporary network outages; disconnect your internet connection for 5 minutes and then reconnect. The agent should intelligently queue its actions and resume operations without sending duplicate notifications once connectivity is restored.

Crucially, confirm that Council deliberation is triggered appropriately. For example, if your sentiment analysis skill returns conflicting scores that differ by more than the uncertainty_threshold of 0.3, the agent should invoke the Council for multi-perspective analysis. Review the SILA logs to ensure that every action, decision, and data access is meticulously recorded with the proper cryptographic hashes, confirming compliance. Finally, verify that the Portable Mind export (which you will create in the next step) accurately contains all the agent’s configuration state, including its current budget remaining, reflecting its operational status. For a full day of monitoring 10 news sources and posting to Slack, expect approximately $0.50 in API costs. If costs significantly exceed $1.00, it’s advisable to review the breadth of your web_search queries in the skill configuration, potentially narrowing parameters to more specific domains.

Step 12: Exporting Your Agent as a Portable Mind JSON

One of the most powerful features of Sutra.team is its ability to export an agent’s complete state into a Portable Mind JSON file. This feature ensures true ownership, portability, and version control for your autonomous agents. To export your CryptoSentinel agent, execute the following command in your terminal:

sutra export --format portable-mind --output crypto_sentinel_v1.json

This command will generate a JSON file, typically around 40-60KB in size, named crypto_sentinel_v1.json. This file encapsulates every single aspect of your agent: its defined mandate, the precise configurations of all its skills, the KARMA budget limits, the SILA audit policies, the Council deliberation rules, its deployment targets, and even its execution history. The Portable Mind Format adheres to schema version 2.1, guaranteeing backward compatibility with future releases of Sutra.team.

The true utility of this format becomes apparent in several scenarios. You can easily version control this file, treating your agent’s configuration as code:

git add crypto_sentinel_v1.json
git commit -m "Production agent v1.0 with $5 daily budget and Council deliberation"

This allows you to track changes, revert to previous versions, and collaborate with team members on agent development. If you need to migrate your agent to a new server, deploy it in a different environment, or share it with colleagues, simply transfer this JSON file. On the target machine, run sutra import crypto_sentinel_v1.json. The agent will then resume operation exactly where it left off, including its next scheduled heartbeat and its current budget status, ensuring seamless continuity. This level of portability is paramount, as it ensures you retain complete ownership of your AI agent, preventing vendor lock-in. Furthermore, the JSON file is human-readable, allowing for advanced customization or debugging by directly editing its contents, though validating the file after manual changes with sutra validate is always recommended to ensure logical consistency.

Troubleshooting: When Agents Stop or Burn Budget

Even with the most meticulous setup, autonomous agents can encounter issues. Understanding common problems and their solutions is crucial for maintaining a healthy and efficient Sutra.team deployment.

If your agent’s status displays as “STALLED” after deployment, the first step is to diagnose the root cause by examining the logs. Run sutra logs --errors --last 50 to retrieve the most recent 50 error messages. A frequent culprit for stalled agents is expired API keys. If this is the case, update your .env file with the renewed keys and then run sutra restart to resume operation. Network timeouts often point to corporate firewall blocks on port 443; ensure that Sutra.team domains are whitelisted or configure your HTTP_PROXY environment variables correctly.

If KARMA throttles your agent’s execution despite having remaining tasks, it indicates that the budget for specific skills might be too restrictive. You can either increase the daily_budget_usd in karma.yaml or, more precisely, reduce the per_skill_limits for particularly expensive operations like web_search. Unexpected cost spikes are almost always attributable to web_search queries that are overly broad and lack specific site restrictions. To mitigate this, narrow your search parameters to specific, trusted domains (e.g., site:coindesk.com).

Should Council deliberation enter an infinite loop, it typically means the uncertainty_threshold is set too low, making the agent overly sensitive to minor data variations. Try raising this threshold above 0.1 to allow for more tolerance in conflicting signals. Slack deployment failures are commonly due to rotated webhook URLs; regenerate them in your Slack app settings and update your deployment.yaml file accordingly. Missed heartbeats are a strong indicator of system clock drift. Install ntpdate (or its equivalent for your OS) and synchronize your system clock with reliable NTP servers like pool.ntp.org immediately. Finally, for skill import errors, verify that your Git repository URLs are accessible and that they contain valid skill.yaml manifests with correct semantic versioning defined. These troubleshooting steps will help you quickly resolve most common issues and keep your Sutra.team agents running smoothly.

Frequently Asked Questions

What makes Sutra.team different from OpenClaw?

Sutra.team serves as an overarching operating system layer specifically designed for deploying and managing autonomous agents, many of which are built using OpenClaw skills. While OpenClaw itself provides a rich library of over 32 fundamental skills—covering capabilities like browser automation, email management, and advanced search functions—Sutra.team focuses on the critical, production-grade aspects of agent deployment. This includes robust cost governance via KARMA, immutable audit compliance through SILA, and sophisticated multi-agent orchestration. Essentially, OpenClaw provides the raw capabilities or “skills” an agent possesses, while Sutra.team provides the infrastructure and intelligence to deploy, manage, and scale these agents autonomously in a real-world environment. Sutra.team additionally offers features such as proactive heartbeat scheduling, the unique Portable Mind Format for agent ownership, and the powerful Council deliberation mechanism, which are not native to OpenClaw. Therefore, the two platforms are complementary: you leverage OpenClaw for an agent’s capabilities and Sutra.team for its autonomous operation and management.

How does KARMA prevent runaway API costs?

KARMA is Sutra.team’s integrated, real-time budget tracking and enforcement system, specifically designed to prevent unexpected and excessive API expenditures. Users define strict daily and monthly spending caps in USD within the karma.yaml configuration. Every time an agent invokes a skill that incurs an API cost (e.g., an LLM call or web search), KARMA deducts its estimated cost from the agent’s running budget. This estimation uses precise token counting where applicable. When an agent approaches 80% of its allocated budget, KARMA intelligently switches it into a “throttle mode.” In this mode, the agent automatically adapts its behavior, potentially opting for cheaper model tiers, reducing the depth or breadth of data retrieval (like web search results), or prioritizing less resource-intensive operations. If the agent reaches 100% budget consumption, KARMA will pause non-critical skills to halt further spending while ensuring essential functions, such as heartbeat checks, continue to maintain the agent’s presence. Users receive automated alerts at 50%, 80%, and 100% budget thresholds, providing ample warning and control. This proactive and dynamic budget enforcement mechanism effectively eliminates the risk of “bill shock” often associated with autonomous agent deployments.

Can I use my own LLM API keys with Sutra.team?

Absolutely. Sutra.team is built with a strong emphasis on user control and data privacy, which is why it mandates a Bring Your Own Key (BYOK) approach for all Large Language Model (LLM) inference. This means you must provide your own API keys for services such as Anthropic, OpenAI, Gemini, or DeepSeek. Alternatively, you can configure Sutra.team to use local LLM models via platforms like Ollama. Your API keys are never stored on Sutra.team’s servers; instead, they are encrypted at rest on your local machine using robust AES-256 encryption and are never exposed in any logs. The platform acts purely as a secure router, directing your LLM requests directly from your infrastructure to the respective LLM provider’s endpoints. This architecture ensures that your sensitive data and API calls remain entirely within your control, minimizing security risks and giving you full transparency over your infrastructure and costs, while Sutra.team handles the complex orchestration layer.

What is the Portable Mind Format?

The Portable Mind Format is a unique and comprehensive JSON export developed by Sutra.team that encapsulates the complete operational state and configuration of your autonomous agent. This JSON file, typically ranging from 40-60KB, contains every critical detail: the agent’s mandate, the precise configurations of all its integrated skills, the KARMA budget limits, the SILA audit policies, the rules governing Council deliberation, its designated deployment targets (e.g., Slack, Telegram), and a summary of its execution history. It adheres to schema version 2.1, ensuring compatibility across different Sutra.team versions. The primary benefit of the Portable Mind Format is true agent ownership and portability. You own this file entirely, allowing you to version control it using Git, easily migrate your agent between different servers or environments, and use it for robust backup and recovery. By simply importing this JSON file into any Sutra.team instance, your agent can resume operations exactly where it left off, including its next scheduled heartbeat and its remaining budget allocations, ensuring seamless continuity and eliminating vendor lock-in.

How does the Council deliberation skill work?

The Council deliberation skill, an integral part of the OpenClaw framework integrated into Sutra.team, is designed to enhance the reliability and robustness of an agent’s decision-making process, particularly when faced with ambiguity or complex, high-stakes choices. When an agent encounters a situation where its initial assessment is uncertain or contradictory (e.g., conflicting sentiment analysis results or ambiguous market signals), it can invoke the Council. This triggers a process where eight specialist perspectives are brought to bear on the problem. Each perspective is inspired by established decision-making frameworks: Right View (data accuracy), Right Intention (bias detection), Right Speech (output safety), Right Action (ethical validation), Right Livelihood (business alignment), Right Effort (resource optimization), Right Mindfulness (context awareness), and Right Concentration (focused problem-solving). Each of these “specialist agents” analyzes the problem from its unique viewpoint and provides an assessment, often including a confidence score. Sutra.team then weights these responses based on their confidence scores, generating a consensus decision. This multi-perspective analysis significantly mitigates the risk of single-model hallucinations, biases, or narrow interpretations driving autonomous actions, ensuring more thoughtful and well-rounded decisions. The entire deliberation process, including individual perspectives and their rationales, is meticulously logged by SILA for auditability.