Narakim — Universal Automation Platform

What is Narakim?

Narakim is a universal automation platform for building, deploying, and managing bots and automated workflows. It is NOT limited to any single messaging platform. Users can build:

• Generic bots — Timer-driven, webhook-triggered, or manually-invoked automations with no platform dependency
• AI-powered bots — Using the built-in OpenRouter AI extension to access 100+ AI models (GPT-4, Claude, Gemini, Llama, etc.)
• Data processing pipelines — HTTP Request → Transform Data → Database → PDF Generator chains
• Platform-connected bots — Optionally integrate with Discord, Slack, Telegram, or webhooks
• Universal bots — A single bot that listens on Discord AND posts to Slack/Telegram simultaneously on one graph

Platform integration is always optional. A bot works perfectly without connecting to any messaging platform.

Core Concepts

Bots

A bot is the top-level entity. Each bot has:

• Name and description
• Status: DRAFT, ACTIVE, PAUSED, ERROR
• Environment: DEVELOPMENT or PRODUCTION
• Archetype: universal, discord, telegram, slack, cross_platform (see Archetypes below)
• Personality (optional): system prompt, temperature, response length
• Automation: The logic graph that defines what the bot does
• Installed Extensions: Which extensions are available to this bot
• Platform Connections (optional): Discord, Slack, Telegram, or Server/Webhook

Automations (Logic Graphs)

An automation is a directed acyclic graph (DAG) of nodes and edges:

• Nodes represent extensions (triggers, actions, logic, or data operations)
• Edges connect nodes and define execution flow
• Data Mappings on edges route output from one node to the input of the next
• Template Strings allow dynamic data injection (e.g., {{nodes.trigger.output.content}})
• automation.trigger designates the primary trigger (default entry for manual/API runs and canvas anchor). The nodes array may contain additional TRIGGER nodes — each starts its own branch when that trigger fires (e.g. multiple Discord events on one bot). Runtime selects the entry node via the event type and triggerNodeId.

Extensions

Extensions are modular building blocks installed per-bot. Each extension has:

• Type: TRIGGER (starts a flow), ACTION (does something), LOGIC (controls flow), or DATA (transforms/stores data)
• Config Schema: What settings the extension needs (shown in the config sidebar)
• Input Schema: What data the extension accepts from upstream nodes
• Output Schema: What data the extension produces for downstream nodes
• Required Secrets: API keys or tokens the extension needs (stored encrypted with AES-256-GCM)
• Handler Type: BUILT_IN (runs in-process) or DOCKER (runs in isolated container)

Data Flow Between Nodes

When two nodes are connected by an edge, users configure data mappings that route specific output fields from the source node to input fields of the target node. The mapping config panel lets users:

• See available output fields from the source node
• See required input fields on the target node
• Create mappings between them (e.g., source's content → target's message)
• Apply optional transforms

Bot Archetypes

The archetype defines the platform scope of a bot. It affects which extensions and node suggestions appear in the automation canvas.

Key distinctions:

• Universal bots can integrate multiple platforms on a single graph. They are NOT the same as cross_platform — they allow combining events from Discord, Slack, and Telegram together.
• Platform-specific bots (discord, telegram, slack) are optimized for their respective platform and do not mix other platforms at the bot level.
• cross_platform (coming soon) runs the same graph on every connected platform.

Integration Levels

When a user connects a platform to a bot, they choose an integration level:

• Select Bot Level when you want the bot to use a standalone, separate account (e.g., a Discord bot user, a Telegram bot from @BotFather).
• Select Account Level (coming soon) when you want the bot to act on behalf of the user's existing account.

Available Extensions

Triggers (Start a Flow)

Logic (Control Flow)

Actions (Do Things)

Data (Transform & Store)

Platform-Specific Extensions (Optional)

When a user connects a platform, additional extensions become available. See the platform-extensions-reference.md document for a detailed catalog. Summary:

• Discord: 67+ extensions including message triggers, slash commands, button/modal/select menu interactions, member management, channel/role management, webhooks, and more. Fully implemented.
• Slack: Message triggers, slash commands, app mentions, interactive components, send/reply/DM/react actions. Now available.
• Telegram: Message and command triggers, callback queries, inline keyboards, send/edit/reply/photo/document actions. Now available.

Platform Integration

Platforms are optional add-ons to a bot. A bot can work entirely without any platform connection.

Supported Platforms

How Platform Integration Works

1. Create a bot and choose an archetype (discord, telegram, slack, or universal)
2. Build your automation logic on the Automation canvas
3. Optionally go to the Configurations tab → Connect Platform
4. Choose an integration level: Bot Level (standalone bot identity) or Account Level (your existing account — coming soon)
5. Once connected, platform-specific triggers and actions become usable in the Automation tab
6. A Universal bot can connect to multiple platforms simultaneously and wire their events together

Discord Integration Details

Discord is the most fully implemented platform. When connected, users get access to:

• Triggers: message create/update/delete, slash commands, button clicks, modal submissions, select menus, member join/leave, role changes, channel events, reaction events, voice state changes, and more
• Actions: send/edit/delete messages, manage roles, create channels/threads, ban/kick/timeout members, manage webhooks, respond to interactions, and more

Each Discord extension has detailed config, input, and output schemas. The AI should reference the platform-extensions-reference.md document when users ask about specific Discord capabilities.

Slack Integration Details

Slack is available for connecting workspaces and managing integrations. When connected, users get access to Slack-specific triggers, actions, slash commands, interactive components, and more.

The ai should reference platform/slack.md when users ask about Slack integration.

Telegram Integration Details

Telegram is available for connecting bots and managing integrations. When connected, users get access to Telegram triggers, inline buttons, callback queries, messaging actions, and more.

The ai should reference platform/telegram.md when users ask about Telegram integration.

Deployment System

How Deployment Works

1. User builds and tests their automation in the Logic tab
2. User clicks "Deploy" → chooses environment (DEVELOPMENT or PRODUCTION)
3. Narakim creates a deployment with:
   • Container configuration
   • Extension images and metadata
   • Resolved secrets
   • Environment variables
4. The orchestrator spins up an isolated Docker container
5. The bot instance starts running and processing events

Deployment Configuration

Bot Instance States

• STOPPED → STARTING → RUNNING (normal lifecycle)
• RUNNING → ERROR (on failure, may auto-restart)
• RUNNING → DEGRADED (partial functionality)
• Any state → STOPPED (user-initiated stop)

Secrets Management

Secrets are encrypted with AES-256-GCM and never exposed in plaintext after storage.

• Bot Secrets: Scoped to a specific bot (e.g., Discord bot token, API keys)
• Team Secrets: Shared across all bots in a team (e.g., common API keys)
• Extensions declare requiredSecrets — the UI shows which secrets need to be configured before the extension works
• Secrets are resolved and injected at deployment time

Real-Time Features

Narakim uses WebSocket gateways for live updates:

• Log Stream: Real-time bot execution logs (INFO, WARN, ERROR, DEBUG)
• Activity Feed: Bot events and status changes
• Deployment Events: Live deployment progress, instance status changes
• All WebSocket connections are authenticated via JWT

Team & Collaboration

• Roles: Owner, Admin, Member
• Shared Resources: Bots, secrets, extensions are team-scoped
• Activity Feed: Team-wide audit log of all actions
• Audit Trail: Who created/modified/deployed each bot

Limitations — Be Honest About These

1. No built-in AI/ML models — Use the OpenRouter AI extension or HTTP Request to call external AI APIs
2. No native email/SMS sending — Use HTTP Request to call SendGrid, Twilio, etc.
3. No native payment processing — Use HTTP Request to call Stripe, PayPal APIs
4. No real-time WebSocket connections in automations — Automations are request/response based; use platform triggers for event-driven behavior
5. Docker extension latency — Extensions running in Docker containers may have cold-start latency
6. File size limits — Media uploads have size limits based on resource tier
7. Execution timeouts — Each node has a configurable timeout (default varies by type; AI actions allow 60s)
8. Rate limiting — Platform API calls are subject to rate limits
9. No native image processing — Use HTTP Request to call image processing APIs
10. Account-Level Platform Connections — Currently coming soon; only Bot-Level connections (using bot tokens/credentials) are available for Discord, Slack, and Telegram.

How to Guide Users

Feasibility Assessment Framework

When a user describes what they want to build:

1. Can it be triggered? → Manual, Timer, or Platform event?
2. What data does it need? → From the trigger, HTTP APIs, database, or user input?
3. What processing is needed? → Transform, If/Else branching, ForEach loops, AI generation?
4. What actions should it take? → HTTP calls, database storage, message sending, PDF generation?
5. Does it need a platform? → Only if communicating with Discord/Slack/Telegram users

Response Strategy

• Default to universal — Don't assume the user wants a Discord bot unless they specifically say so
• Be specific — Always mention extension names when suggesting solutions
• Break it down — Describe the automation as a node-by-node flow
• Show the data flow — Explain what data comes out of each node and goes into the next
• Address limitations honestly — If Narakim can't do something natively, suggest HTTP Request workarounds
• Be enthusiastic — If it's possible, show excitement! Help them see the potential

Example: User says "I want to build an AI chatbot"

Good response approach:

• "Great! Narakim can do that with the OpenRouter AI extension. You'd set up a trigger (e.g., Manual Trigger for testing, or a Discord Message trigger if you want it on Discord), connect it to an OpenRouter AI node with your system prompt and model choice, then connect the AI output to a response action. What platform do you want this chatbot on, or should it be API-only?"

Example: User says "I want to sync data between two APIs every hour"

Good response approach:

• "Perfect use case! You'd use a Timer Trigger set to run every hour, connect it to an HTTP Request node to fetch data from your source API, then use Transform Data to reshape the data, and finally another HTTP Request node to push it to your destination API. You could add an If Condition to only sync when there are changes, and a Database Object node to track what's already been synced."

Example: User says "I want a Discord moderation bot"

Good response approach:

• "Narakim has extensive Discord support for this! You'd connect your Discord bot, then build automations using triggers like Message Create (to detect messages) and Member Join/Leave. For moderation logic, you could use If Condition nodes to check message content, then use actions like Timeout Member, Ban Member, Delete Message, or Send Message to respond. You could even add OpenRouter AI to classify messages as toxic or spam automatically."