@adminide-stack/yantra-help-browser 12.0.16-alpha.2 → 12.0.16-alpha.21

package/lib/templates/content/openclaw/openclaw-architecture.md

@@ -0,0 +1,202 @@
+# OpenClaw Architecture
+
+A deeper look at the OpenClaw open-source framework that powers every Yantra AI employee — understanding the architecture helps you get the most out of your AI employees.
+
+## Core Components
+
+### 1. Event Bus
+
+The event bus is the central nervous system of an OpenClaw agent:
+
+- Receives events from all connected tool integrations
+- Normalizes diverse event formats into a unified schema
+- Routes events to appropriate processing pipelines
+- Maintains event ordering and deduplication
+- Provides replay capability for debugging and recovery
+
+### 2. Context Store
+
+The persistent memory layer that enables agents to maintain organizational context:
+
+**Document Store**:
+
+- Indexed content from Notion, Confluence, and other documentation tools
+- Searchable by topic, keyword, and semantic similarity
+- Automatically updated as source documents change
+
+**Event Store**:
+
+- Complete history of all processed events
+- Queryable by timestamp, source, entity, and content
+- Enables historical analysis and pattern detection
+
+**Knowledge Graph**:
+
+- Relationships between entities (people, projects, customers, issues)
+- Automatically constructed and updated from processed events
+- Traversable for multi-hop context queries (e.g., "Who fixed the auth issue that affected Acme Corp last month?")
+
+**Working Memory**:
+
+- Short-term context for active conversations and workflows
+- Maintained across interaction sessions
+- Cleared according to retention policies
+
+### 3. Reasoning Engine
+
+The decision-making component that determines how to respond to events:
+
+**Rule-Based Reasoning**:
+
+- Configurable rules for alert thresholds, escalation paths, and auto-actions
+- Priority classification based on customer tiers and severity definitions
+- Business logic for CRM updates, ticket creation, and similar workflows
+
+**AI-Powered Reasoning**:
+
+- Natural language understanding for interpreting messages and events
+- Context synthesis for combining data from multiple sources
+- Action planning for multi-step workflows
+- Response generation for messages and content drafts
+
+**Hybrid Approach**:
+
+- Rules handle deterministic decisions (severity thresholds, routing logic)
+- AI handles nuanced decisions (content drafting, context summarization, pattern recognition)
+- Human oversight for high-stakes actions via the approval workflow
+
+### 4. Action Executor
+
+The component responsible for carrying out decisions:
+
+- **Action Queue**: Prioritized queue for pending actions
+- **Tool Adapters**: Standardized interfaces for each integration
+- **Retry Logic**: Automatic retry with backoff for transient failures
+- **Rollback Support**: Ability to undo actions when needed
+- **Rate Limiting**: Respects API rate limits for all connected tools
+
+### 5. Approval Gateway
+
+The human-in-the-loop component for supervised operations:
+
+- Presents proposed actions with full context
+- Delivers approval requests through configured channels
+- Processes approve/edit/reject decisions
+- Learning system that adapts based on human feedback
+
+## Data Flow
+
+### Event Processing Pipeline
+
+```
+Tool Event
+    ↓
+Event Bus (normalize, deduplicate, route)
+    ↓
+Context Enrichment (query knowledge graph, find correlations)
+    ↓
+Reasoning Engine (classify, decide, plan)
+    ↓
+Action Generation (determine appropriate response)
+    ↓
+Approval Gateway (if supervised) or Action Executor (if autonomous)
+    ↓
+Tool Action (execute via API)
+    ↓
+Audit Log (record everything)
+```
+
+### Context Query Pipeline
+
+```
+User Question
+    ↓
+Natural Language Understanding (parse intent)
+    ↓
+Context Store Query (search knowledge graph, event store, documents)
+    ↓
+Result Synthesis (compile, summarize, structure)
+    ↓
+Response Generation (format answer with citations)
+    ↓
+Delivery (via configured channel)
+```
+
+## Model Integration
+
+### Supported AI Model Providers
+
+OpenClaw supports multiple AI model providers:
+
+- **OpenAI**: GPT-4, GPT-4 Turbo for complex reasoning
+- **Anthropic**: Claude for nuanced analysis and long-context tasks
+- **Custom Models**: Support for self-hosted models via standard APIs
+
+### Model Selection Logic
+
+The reasoning engine selects the appropriate model based on:
+
+- Task complexity (simple classification vs. multi-step reasoning)
+- Context length requirements
+- Latency requirements
+- Cost optimization
+
+### Model Fallback
+
+If a model provider is unavailable, OpenClaw automatically falls back to:
+
+1. Same provider, smaller model
+2. Alternative provider with similar capabilities
+3. Rule-based processing for critical actions
+
+## Plugin System
+
+### Integration Plugins
+
+Each tool integration is implemented as an OpenClaw plugin:
+
+- Standardized interface for event consumption and action execution
+- Independent versioning and updates
+- Isolation from other plugins for stability
+- Community-contributed plugins for less common tools
+
+### Custom Plugins
+
+Organizations can develop custom plugins for:
+
+- Proprietary internal tools
+- Industry-specific systems
+- Custom workflow automation
+- Specialized data sources
+
+## Scalability
+
+### Event Processing
+
+- Horizontal scaling of event processors
+- Automatic load balancing across processing nodes
+- Queue-based architecture for traffic spikes
+- Back-pressure handling for sustained high volume
+
+### Storage
+
+- Automatic storage scaling based on data volume
+- Tiered storage for hot, warm, and cold data
+- Configurable retention policies per data type
+- Efficient indexing for fast context retrieval
+
+## Open Source Benefits
+
+### Transparency
+
+- All agent logic is auditable in the OpenClaw source code
+- No black-box decision making
+- Community review of security-sensitive components
+- Published architecture documentation
+
+### Reliability
+
+- Battle-tested through diverse production deployments
+- Continuous improvement from the global contributor community
+- Rapid bug fixes and security patches
+- Extensive test coverage and quality standards

package/lib/templates/content/openclaw/openclaw-contribution.md

@@ -0,0 +1,107 @@
+# Contributing to OpenClaw
+
+Yantra is proudly built on OpenClaw, and we actively support and contribute to the open-source community. This guide explains how Yantra portal users can engage with the OpenClaw project.
+
+## Yantra's Commitment to Open Source
+
+### Why We Build on Open Source
+
+- **Transparency**: Our customers can audit the AI agent logic that handles their data
+- **Community innovation**: Improvements from the broader community benefit all Yantra users
+- **Trust**: Open source builds trust through verifiability
+- **Sustainability**: A healthy open-source ecosystem ensures long-term platform viability
+
+### How Yantra Contributes
+
+- Core framework improvements discovered through enterprise usage
+- Security patches and hardening measures
+- New integration connectors (contributed back after internal development)
+- Documentation, guides, and best practices
+- Bug fixes identified through our monitoring and testing infrastructure
+
+## Engaging with OpenClaw from the Yantra Portal
+
+### Reporting Issues
+
+If you encounter behavior in your Yantra AI employee that may stem from the OpenClaw framework:
+
+1. **Report through Yantra Support first** — Our team will investigate and determine if it's a Yantra-specific or OpenClaw-level issue
+2. If it's an OpenClaw issue, we'll file it upstream and track the fix
+3. You'll receive updates as the fix progresses through our release cycle
+
+### Feature Requests
+
+Feature ideas that would benefit the OpenClaw ecosystem:
+
+1. Share your idea through Yantra Support or your account manager
+2. We evaluate the request for both Yantra-specific and community-wide value
+3. Qualifying features are proposed to the OpenClaw community
+4. Accepted features are developed with community input
+
+### Viewing OpenClaw Source
+
+For organizations that want to audit the AI agent logic:
+
+1. Access the [OpenClaw GitHub repository](https://github.com/openclaw)
+2. Review the agent framework, reasoning engine, and tool integration code
+3. Compare with Yantra's behavior to verify expected operation
+4. Raise questions through Yantra Support or the OpenClaw community
+
+## For Developers in Your Organization
+
+### Custom Integration Development
+
+If your organization has developers who want to build custom OpenClaw plugins:
+
+1. Review the [OpenClaw Plugin Development Guide](https://docs.openclaw.dev/plugins)
+2. Develop and test the plugin against the OpenClaw framework
+3. Contact Yantra Support to deploy custom plugins in your managed environment
+4. Optionally contribute the plugin to the OpenClaw community
+
+### API Extensibility
+
+Yantra exposes OpenClaw's capabilities through managed APIs:
+
+- Agent configuration and management
+- Event stream access
+- Custom workflow definitions
+- Context store queries
+
+See the [API Overview](/help-center/scope-api/api-overview) for details.
+
+## Community Resources
+
+### OpenClaw Channels
+
+- **GitHub**: Source code, issues, and pull requests
+- **Community Forum**: Discussions, questions, and showcase
+- **Discord**: Real-time chat with community members and maintainers
+- **Blog**: Release announcements, deep dives, and roadmap updates
+
+### Yantra-Specific Resources
+
+- **Documentation**: This help center
+- **Support**: Direct support for Yantra-specific questions
+- **Feature Updates**: Yantra blog and changelog for platform updates
+- **Community**: Yantra user community for sharing best practices
+
+## OpenClaw License
+
+OpenClaw is released under a permissive open-source license that allows:
+
+- Commercial use (as Yantra does)
+- Modification and distribution
+- Private use and development
+- Patent grant for contributors
+
+The license ensures that the OpenClaw community remains sustainable while allowing organizations to build commercial products on top of the framework.
+
+## Why This Matters for You
+
+As a Yantra user, OpenClaw provides you with:
+
+1. **Confidence**: The core technology is transparent and auditable
+2. **Longevity**: Open source ensures the technology isn't locked to any single vendor
+3. **Innovation pace**: Community contributions accelerate feature development
+4. **Security**: Open source components receive scrutiny from the global security community
+5. **Flexibility**: Custom extensions are possible through the plugin architecture

package/lib/templates/content/openclaw/openclaw-overview.md

@@ -0,0 +1,152 @@
+# OpenClaw Overview
+
+Yantra is built on **OpenClaw**, an open-source AI agent framework that provides the foundation for all Yantra AI employees. This guide explains what OpenClaw is, how it powers Yantra, and how the Yantra portal supports the OpenClaw ecosystem.
+
+## What is OpenClaw?
+
+OpenClaw is an open-source platform for building, deploying, and managing AI agents. It provides:
+
+- **Agent Framework**: A structured approach to building AI agents that can observe, reason, and act
+- **Tool Integration Layer**: Standardized connectors for popular tools and APIs
+- **Execution Runtime**: Sandboxed environments for safe agent execution
+- **Memory System**: Persistent context storage for agents to maintain state across interactions
+- **Orchestration**: Multi-agent coordination for complex workflows
+
+### Community and Adoption
+
+- Open source on GitHub with an active worldwide contributor community
+- Trusted by organizations ranging from startups to enterprises
+- Continuous improvement from community contributions and security audits
+- Production-tested across thousands of deployments
+
+## How Yantra Uses OpenClaw
+
+### The Relationship
+
+Yantra is to OpenClaw what a managed cloud database is to an open-source database engine:
+
+- **OpenClaw** provides the core AI agent technology — open source, auditable, and extensible
+- **Yantra** provides enterprise-grade managed infrastructure, tooling, and support on top of OpenClaw
+
+### What Yantra Adds
+
+On top of the OpenClaw foundation, Yantra provides:
+
+| Capability           | OpenClaw (Self-Hosted)     | Yantra (Managed)            |
+| -------------------- | -------------------------- | --------------------------- |
+| Core agent framework | ✅                         | ✅                          |
+| Tool integrations    | Community-maintained       | Production-grade, one-click |
+| Deployment           | Self-managed (Docker, K8s) | Zero-config, fully managed  |
+| VM isolation         | You provision              | Automatic per-customer      |
+| Security hardening   | You implement              | Enterprise-grade included   |
+| Monitoring           | You build                  | Built-in dashboards         |
+| Support              | Community forums           | Dedicated support team      |
+| Compliance           | You manage                 | SOC 2, GDPR included        |
+| Updates              | Manual                     | Automatic, zero-downtime    |
+
+### Technical Integration
+
+Yantra's architecture layers on OpenClaw:
+
+```
+Yantra Dashboard (Configuration, Monitoring, Audit)
+         ↕
+Yantra Infrastructure Layer (VM Isolation, Gateway, Scaling)
+         ↕
+OpenClaw Agent Runtime (Agent Logic, Memory, Tools)
+         ↕
+Your Tools (Slack, GitHub, HubSpot, Sentry, etc.)
+```
+
+## OpenClaw Agent Architecture
+
+### Agent Components
+
+**Perception Layer**
+
+- Receives events from connected tools via webhooks and APIs
+- Normalizes events into a standardized format
+- Enriches events with historical context
+
+**Reasoning Layer**
+
+- Analyzes events using AI models (GPT-4, Claude, etc.)
+- Traverses the context graph to understand relationships
+- Determines appropriate responses based on rules and learning
+
+**Action Layer**
+
+- Executes approved actions through tool APIs
+- Manages action queues and retry logic
+- Logs all actions for audit purposes
+
+**Memory Layer**
+
+- Persistent storage for organizational context
+- Knowledge graph of relationships between people, projects, and events
+- Conversation history and decision records
+- Pattern recognition data
+
+### Extensibility
+
+OpenClaw's plugin architecture allows:
+
+- Custom tool integrations for proprietary systems
+- Custom action types for organization-specific workflows
+- Custom reasoning rules for domain-specific logic
+- Third-party model integration for specialized AI capabilities
+
+## Yantra's OpenClaw Contributions
+
+Yantra actively contributes back to the OpenClaw community:
+
+### Code Contributions
+
+- Performance improvements and optimizations
+- Security patches and hardening measures
+- New integration connectors developed for Yantra customers
+- Testing infrastructure and quality improvements
+
+### Community Support
+
+- Active participation in community forums and discussions
+- Documentation contributions and guides
+- Sponsorship of OpenClaw development initiatives
+- Enterprise feedback channeled into open-source improvements
+
+## Using OpenClaw Through Yantra
+
+### For Non-Technical Teams
+
+Yantra abstracts away all OpenClaw complexity:
+
+- No code, no terminal, no configuration files
+- Setup through a visual dashboard
+- Managed updates and maintenance
+- Support team available for any issues
+
+### For Technical Teams
+
+Yantra provides the managed infrastructure while preserving OpenClaw's power:
+
+- Custom workflow configuration through the dashboard
+- API access for programmatic management
+- Audit logs showing agent decision-making
+- Ability to inspect and understand agent behavior
+
+## Getting Started
+
+To leverage OpenClaw through Yantra:
+
+1. Sign up for a Yantra account
+2. Connect your tools through the Integrations dashboard
+3. Configure your AI employee — powered by OpenClaw under the hood
+4. Your OpenClaw-based agent begins processing events immediately
+
+No OpenClaw knowledge is required to use Yantra. The platform handles all OpenClaw setup, configuration, and management automatically.
+
+## Resources
+
+- [OpenClaw GitHub Repository](https://github.com/openclaw) — Source code and documentation
+- [OpenClaw Community](https://community.openclaw.dev) — Forums and discussions
+- [Yantra API Documentation](/help-center/scope-api/api-overview) — Programmatic access to your Yantra-managed OpenClaw agents

package/lib/templates/content/platform-features/always-watching.md

@@ -0,0 +1,63 @@
+# Always Watching — 24/7 Tool Monitoring
+
+Yantra AI employees continuously monitor all connected tools and services, ensuring nothing important slips through the cracks — even outside business hours.
+
+## How Continuous Monitoring Works
+
+When you connect your tools to Yantra, your AI employee begins ingesting events from every connected service simultaneously. It processes messages, commits, error logs, CRM updates, emails, and more — correlating data points across your entire stack in real time.
+
+### What Gets Monitored
+
+| Tool Category          | Examples                   | What's Tracked                                       |
+| ---------------------- | -------------------------- | ---------------------------------------------------- |
+| **Communication**      | Slack, Teams, Email        | Channel messages, direct messages, threads, mentions |
+| **Development**        | GitHub, GitLab, Bitbucket  | Pull requests, commits, deployments, code reviews    |
+| **Error Tracking**     | Sentry, Datadog, PagerDuty | Error spikes, new exceptions, regression alerts      |
+| **Project Management** | Linear, Jira, Asana        | Ticket updates, sprint changes, assignment shifts    |
+| **CRM**                | HubSpot, Salesforce        | Deal stage changes, new contacts, activity logs      |
+| **Documentation**      | Notion, Confluence         | Page updates, new documents, comment threads         |
+
+## The Difference From Traditional Monitoring
+
+### Traditional Approach
+
+- You check each tool manually every morning
+- Important updates get buried in notification noise
+- Cross-tool correlations require mental effort and context switching
+
+### With Yantra
+
+- Your AI employee synthesizes updates across all tools into a **morning briefing**
+- Related events from different tools are **automatically correlated** (e.g., a Sentry error linked to a recent GitHub deploy)
+- You receive **prioritized summaries** instead of raw notifications
+
+## Morning Briefings
+
+Each day, your Yantra AI employee prepares a contextualized summary of everything that happened overnight or since your last check-in:
+
+- **Critical items** that need immediate attention
+- **Updates** on ongoing issues or projects you're tracking
+- **New activity** from customers, teammates, or automated systems
+- **Trends** such as increasing error rates or shifting deal pipelines
+
+## Real-Time Correlation Engine
+
+Yantra doesn't just watch — it **connects the dots**. When a customer reports an issue in Slack, your AI employee simultaneously:
+
+1. Checks error monitoring tools for matching exceptions
+2. Searches project management for existing tickets
+3. Reviews recent deployments for related code changes
+4. Looks up the customer's history and previous interactions
+
+This happens in seconds, surfacing a complete context package instead of requiring you to manually triage across systems.
+
+## Configuring What to Watch
+
+You have full control over monitoring scope:
+
+- **Channel selection**: Choose which Slack channels, GitHub repos, or Sentry projects to monitor
+- **Priority thresholds**: Set error count thresholds for escalation
+- **Quiet hours**: Define when alerts should be held for batched delivery
+- **Watch lists**: Track specific customers, keywords, or team members
+
+For setup instructions, see [Integrations Overview](/help-center/integrations/integrations-overview).

package/lib/templates/content/platform-features/instant-context.md

@@ -0,0 +1,67 @@
+# Instant Context — Full Picture in Seconds
+
+One of Yantra's most powerful capabilities is delivering comprehensive context about any topic, customer, or issue in seconds — eliminating the hours teams typically spend gathering information across scattered tools.
+
+## The Context Problem
+
+In most organizations, relevant information about a customer, bug, or project lives across multiple systems:
+
+- **Slack**: Conversation history, support threads, internal discussions
+- **CRM**: Deal stages, contact details, meeting notes
+- **GitHub**: Related pull requests, recent deployments, code changes
+- **Error Trackers**: Exception logs, frequency data, affected users
+- **Email**: Customer correspondence, vendor communications
+- **Documents**: Specs, runbooks, post-mortems
+
+To get the full picture, team members spend 30+ minutes switching between tabs and searching through each tool individually. Yantra eliminates this entirely.
+
+## How Instant Context Works
+
+### Ask a Question, Get Everything
+
+When you ask your Yantra AI employee about a customer, issue, or topic, it performs a comprehensive cross-tool search and synthesizes results into a structured briefing:
+
+**Example Query**: _"What's the situation with Acme Corp?"_
+
+**Yantra Response**:
+
+- Last interaction was 3 days ago — Sarah resolved a billing discrepancy
+- Open support ticket (#4521) regarding API rate limits, assigned to Marcus
+- Deal stage: Enterprise renewal, scheduled for next quarter
+- 2 Sentry errors in the past week from their tenant, both low severity
+- Last deployment affecting their environment was Tuesday, no issues reported
+
+### Automatic Context Surfacing
+
+Beyond answering questions, Yantra proactively surfaces context when it detects you need it:
+
+- **Before meetings**: Sends a brief with all recent activity related to the attendees
+- **When issues arise**: Automatically pulls history of similar problems and past resolutions
+- **During onboarding**: Provides new team members with comprehensive background on any topic
+
+## Context Memory
+
+Unlike traditional search tools that only find documents, Yantra maintains a **living memory** of your organization:
+
+- Every conversation, decision, and action is indexed
+- Relationships between people, projects, and issues are tracked
+- Context accumulates over time, making the AI employee more useful with each passing day
+
+## Use Cases
+
+| Scenario                        | Without Yantra                         | With Yantra                   |
+| ------------------------------- | -------------------------------------- | ----------------------------- |
+| Customer bug report             | 2+ hours gathering context             | 30 seconds, full summary      |
+| Preparing for a sales call      | 20 minutes searching CRM and email     | Automatic pre-call brief      |
+| New hire asking about a project | 30-minute explanation from a colleague | Instant comprehensive context |
+| Post-deployment verification    | Manual checking of multiple dashboards | Proactive status report       |
+
+## Privacy and Access Controls
+
+Instant context respects your organization's access controls:
+
+- AI employees only access tools and channels they've been granted permission to
+- Sensitive information can be excluded from context surfacing
+- All context queries are logged in the audit trail
+
+For more on security, see [Security Overview](/help-center/security-compliance/security-overview).

package/lib/templates/content/platform-features/instant-onboarding.md

@@ -0,0 +1,80 @@
+# Instant Onboarding — New Hires Productive on Day One
+
+Yantra transforms team onboarding by giving new hires immediate access to your organization's complete institutional memory, eliminating the weeks-long ramp-up period.
+
+## The Onboarding Challenge
+
+When a new team member joins, they face a steep learning curve:
+
+- **Customer history**: Who are the key accounts? What issues have they had?
+- **Codebase context**: Why was this architecture chosen? What are the known gotchas?
+- **Process knowledge**: How does the team handle deployments, incident response, or deal negotiations?
+- **Tribal knowledge**: Undocumented decisions, workarounds, and conventions
+
+Traditionally, this context lives in the heads of senior team members, requiring weeks of shadowing, asking questions, and gradually piecing things together.
+
+## How Yantra Enables Instant Onboarding
+
+### Complete Organizational Memory
+
+Your Yantra AI employee has been continuously indexing and correlating information from all connected tools since it was set up. This means it has:
+
+- Full history of customer interactions across Slack, email, and CRM
+- Complete record of technical decisions, deployments, and incidents
+- All project management activity, including ticket discussions and sprint retrospectives
+- Documentation links and relevant context for every topic
+
+### Ask Anything, Get Everything
+
+New hires can simply ask the AI employee any question:
+
+- _"What's the history with Enterprise Customer X?"_ → Full timeline of interactions, issues, and resolutions
+- _"Why do we use this database for that service?"_ → Links to the original discussion, decision rationale, and related tickets
+- _"How does our deploy process work?"_ → Step-by-step guide with links to runbooks and recent deployment logs
+- _"Who should I talk to about the billing module?"_ → Identifies the most active contributors and relevant experts
+
+### Contextual Introductions
+
+When a new team member starts engaging with specific projects or customers, the AI employee proactively shares relevant background:
+
+- Upcoming meetings get enriched with participant history and agenda context
+- Assigned tickets include full background on the customer and issue history
+- Code reviews include context about the module's ownership and recent changes
+
+## Benefits by Role
+
+### New Engineers
+
+- Understand the codebase, architecture decisions, and technical debt without lengthy code archaeology
+- Get context on customer-specific configurations and known issues
+- Access past incident reports and resolution patterns
+
+### New Sales Representatives
+
+- Instantly learn the history of every account in the pipeline
+- Understand common objections and successful approaches from past deals
+- Get briefed before every call without asking colleagues
+
+### New Marketing Team Members
+
+- Access brand voice guidelines and past campaign performance
+- Understand product positioning and competitive landscape
+- Review historical content strategies and engagement metrics
+
+## Onboarding Playbooks
+
+Yantra supports configurable onboarding playbooks that automatically guide new hires through:
+
+1. **Week 1**: Introduction to key tools, customers, and processes
+2. **Week 2**: Deep dives into assigned projects and accounts
+3. **Week 3**: Independent operation with AI-assisted context
+4. **Ongoing**: Continuous learning as the AI employee surfaces relevant context for new situations
+
+## Measuring Onboarding Success
+
+Track onboarding effectiveness through Yantra's analytics:
+
+- **Time to first contribution**: How quickly new hires start producing
+- **Context queries**: How often new hires need to ask for information
+- **Self-service rate**: Percentage of questions answered by the AI employee vs. requiring human input
+- **Ramp-up metrics**: Comparative data across onboarding cohorts