# The Agent Builder Source: https://docs.blinkops.com/docs/agent-builder/agent-builder Overview of the Blink no-code AI Agent Builder for designing and deploying custom security automation agents. The Blink Ops' No-Code Security AI Agent Builder (also known as the Agents) empowers your team to design and deploy custom agents that are purpose-built for your organization’s environment, policies, and infrastructure. Rather than offering a rigid, one-size-fits-all solution, Blink provides a flexible, auditable framework that gives you full control over how agents operate, what they access, and how they make decisions dynamically and in context. Whether you are working in Identity and Access Management, Vulnerability Management, Security Operations and Incident Response, or Governance, Risk, and Compliance (GRC), the Agents enables domain-specific automation that mirrors your real-world processes. Tasks can be distributed across collaborative agents that enforce policy, triage alerts, or generate audit-ready reports, helping you operationalize strategy, not just automate tasks. Built on Blink’s visual workflow interface and automation infrastructure, the Agents is fast, modular, and intuitive. Fully integrated into the BlinkOps platform, your agents inherit the same scalability, security, and reliability that powers the rest of your security automation stack. *** ## Key Features 1. **No-Code Agent Builder:** Design agents and automate workflows with an intuitive no-code interface. 2. **AI-Powered Decision-Making:** Enable agents to make intelligent decisions based on context and data analysis. 3. **Workflow Integration:** Seamlessly integrate agents into BlinkOps workflows to automate end-to-end security processes. 4. **Extensible Architecture:** Easily extend and customize agents as your security needs evolve. 5. **Secure and Scalable:** Built on BlinkOps' enterprise-grade automation platform. *** ## Beneficial for Practitioners and Executives 1. For Security Practitioners, Blink Ops' No-Code Security AI Agents empowers security practitioners to: * **Build Custom Agents:** Design agents that align with your organization's specific security requirements and workflows. * **Control Agent Behavior:** Define the agent's logic, permissions, and access to ensure it operates within defined boundaries. * **Automate Complex Tasks:** Automate time-consuming and repetitive tasks, such as alert triage, data enrichment, and incident response. * **Enhance Threat Detection:** Leverage AI to analyze security data, identify patterns, and detect threats more effectively. * **Improve Incident Response:** Automate incident response workflows to reduce response times and minimize impact. 2. For Executive Buyers, Blink Ops' No-Code Security AI Agents offers executive buyers: * **Increased Security Posture:** Strengthen your organization's security posture by automating critical security processes and improving threat detection and response. * **Reduced Operational Costs:** Lower operational costs by automating tasks and improving the efficiency of your security team. * **Improved Productivity:** Free up security professionals to focus on strategic initiatives, improving overall productivity. * **Enhanced Compliance:** Automate compliance tasks and generate audit-ready reports to meet regulatory requirements. * **Future-Proof Security:** Stay ahead of evolving threats with a flexible and adaptable AI-powered security automation platform. *** ## Related Articles Explore a more in-depth explanation of how the Agents work. Builder Copilot uses generative AI to help you design custom workflows faster, directly within the Workflow Editor. Learn more about how to use it. Use AI to automatically generate a clear, structured summary for each case, helping teams quickly grasp the key facts. Learn more about the Case Summary section. Learn how Agent Blink helps you manage, investigate, and triage cases more efficiently within the Blink platform. Discover how Agent Blink supports the entire investigation lifecycle, from analysis and enrichment to response and remediation, helping analysts take faster, more informed action during case management. *** # Agent Generated Workflow Source: https://docs.blinkops.com/docs/agent-builder/agent-generated-workflows Agent-Generated Workflows enable agents to dynamically create and execute Blink workflows at runtime, extending their capabilities beyond their predefined set of abilities. During task execution, the agent continuously evaluates the work required to fulfill a request. For straightforward operations, it invokes its existing abilities directly. When the task requires complex data transformation, iterative processing, custom logic, or handling large datasets, the agent can determine that generating a dedicated workflow is a more efficient execution strategy. The generated workflow is constructed using Blink's workflow engine and may include: * [Python code](/docs/workflows/building-workflows/actions/basic-actions/code-actions#python) for custom data processing and computation. * [JQ transformations](/docs/builder-copilot/transform-data-output) for structured JSON manipulation. * Ability steps that invoke the agent's existing abilities as reusable subflows. * Standard Blink workflow components such as conditions, loops, and variables to orchestrate execution. Once generated, the workflow is executed within Blink's secure, isolated execution environment. Intermediate processing occurs entirely within the workflow engine, allowing the agent to receive only the relevant output rather than carrying large amounts of intermediate data in its context window. **Note**: Workflows created by an agent are automatically saved in a dedicated workflow pack named: "*Agent Generated: \[Agent Name]*" This execution model provides several advantages: * **Reduced context consumption** by offloading computation from the language model. * **Improved scalability** when processing large datasets or multi-step operations. * **Lower token usage and execution costs** by minimizing unnecessary reasoning. * **Greater reliability and accuracy** by delegating deterministic processing to Blink workflows, reducing opportunities for hallucinations. **Note**: For more information, visit [Best Practices](/docs/agent-builder/best-practices#2-2-handling-large-outputs-&-context-window-mitigation) *** ## Use Case Examples A Blink HR Agent has access to a Fetch Org Chart ability, which returns a large organizational dataset. However, to answer a user's question, the agent only requires a small subset of that information. Instead of processing the entire response within the language model, the agent generates a workflow that: * Invokes the Fetch Org Chart ability as a subflow. * Uses a JQ or Python step to filter, transform, and extract only the relevant data. * Returns the refined result to the agent for reasoning and response generation. By preprocessing the data within the workflow engine, the agent significantly reduces context usage, lowers token consumption, and improves response accuracy. A Blink Compliance Agent has an ability that sends a Slack message to a single user. The agent is asked to notify every employee who has not enabled two-factor authentication (2FA), reminding them to enable it within the next week. After identifying 40 users without 2FA, the agent recognizes that sending 40 individual messages would exceed the maximum number of tool invocations allowed for a single agent task. To complete the request, the agent generates a workflow that: * Invokes a Send Slack to Multiple Users workflow. * Uses a Blink Loop to iterate through the list of users. * Calls the existing Send Slack Message ability as a subflow for each user. * Completes the notification process within the workflow engine before returning the final status to the agent. This approach enables the agent to orchestrate large-scale operations while remaining within execution limits and reusing existing abilities rather than duplicating logic. # Interactive Mode Source: https://docs.blinkops.com/docs/agent-builder/agent-interactive-mode Agents support different interactive modes depending on how users want to interact with them. By default, every agent operates in **Task Mode**, enabling it to run as part of automated workflows and complete defined tasks. For users who need a more dynamic experience, **Interactive Mode** can be enabled when building your agent, allowing real-time conversations and direct engagement with the agent. You can interact with the directly with your agent through, via a chat interface, when 'Interactive Mode' is enabled in 1. **Start** – Interact with the agent's published version through the chat interface. 2. **Test** – Interact with and test the draft version of the agent while building it, allowing you to validate responses in real time. For more information about 'Interactive Test Mode', see this visit [Step 5 of Creating a New Agent](/docs/agent-builder/building-the-agent#creating-a-new-agent) To interact with an agent directly via the chat interface, enable the "Interactive Mode" option in the *Modes* section when building the agent. You can tell whether Interactive Mode is enabled for a specific agent by checking for the icon. *** ## Interactive Mode Once your agent is published, you can start interacting with it directly from the agent interface. Simply hover over the published agent and click **Start** to launch an interactive session. * In the top-right corner, click the icon to view all active ability workflows assigned to the agent. * Interactive Agents support parallel ability execution, enabling multiple abilities to run concurrently. This reduces overall task completion time and can lower token consumption by minimizing the number of agent reasoning iterations. * The agent automatically determines which abilities can execute in parallel based on their defined dependencies, inputs, and outputs. Parallel execution behavior can also be explicitly controlled through agent instructions when defining it's roles and responsibilities to enforce concurrent execution for specific abilities. Agent reasoning proceeds only after all required parallel ability executions have completed. * For Interactive Agents, ability execution may include a combination of automatically executed abilities and abilities requiring user approval. If a user submits a new message instead of approving a pending action, only the pending abilities are marked as stale. Previously completed abilities and their execution results remain preserved and available to the agent. * In the top-left corner, click the icon to access all interactive sessions with the agent. * Rename an interactive session by hovering over the desired session, clicking the menu, and selecting **Rename**. * Start a new interactive session by clicking the icon in the top-right corner of the session panel. A new session will begin automatically. *** # The Agent's Run Logs Source: https://docs.blinkops.com/docs/agent-builder/agent-run-logs How to use agent run logs for testing, debugging, auditing, and validating agent behavior in the Agent Builder. The **Agent's Run Logs** serve as a critical tool for testing, debugging, auditing and validating the behavior of agents built using the Agent Builder. Whether you are developing a new agent from scratch or testing modifications to an existing one, the run logs provide visibility into how your agent executes each step, what data it processes, and where potential issues may arise. These logs are especially useful during the development and testing phases, helping you trace the full lifecycle of an agent's execution, from input ingestion to output generation. By reviewing the logs, builders can quickly identify syntax errors, misconfigured connections and unexpected outputs, significantly reducing the time spent troubleshooting. **Note**: To view an agent’s run logs, you must have `workflow:view` permissions. For more details about agent permissions, see the [agent's permissions guide](/docs/agent-builder/permissions). *** ## Accessing the Agent's Run Logs The Agent's Run Logs provide full visibility into each execution of an agent. These logs help users troubleshoot, monitor behavior, and validate that the agent is functioning as intended. The run logs can be accessed from two main locations: The 'Run Log' tab within the agent builder or in the output of the Agent step. 1. The Agent's Step 2. The 'Run Log' tab within the Agent Builder ## The Agent Step When executing an agent step, the output includes two distinct tabs: ### Run Log (Default Tab) This is the default view that appears as soon as the agent step begins to run. It displays a run log similar to the full run log view in the [Agent Builder](/docs/agent-builder/building-the-agent) page, but optimized for step-level focus. **This step-level run log helps you:** 1. Observe the progression of the step in real time. 2. Review input ingestion and transformations. 3. Identify issues such as malformed input, invalid expressions, or connection errors. 4. Validate that each ability and decision-making point behaves as expected. **Note**: If any agent step involves Abilities (workflows), clicking on it will open a pop-up window showing the execution status and an arrow that will direct you to the ability workflow **Note**: Within a workflow’s run logs, you can click [Agent run log](#the-agent’s-execution-details) link in the top-right corner of the agent step’s output. This opens the detailed [run log](#the-agent’s-execution-details) for that specific agent. *** ### Output Tab This tab shows the agent’s final response along with all related information in `JSON` format, including data such as usage details, session IDs, and execution log details. *** ## Run Log Tab within the Agent Builder **Note:** The run logs collected by the agent are identical to those shown in the Agent Step's Run Log, with one key addition: they also include the task inputs sent to the agent. This provides additional visibility into what data was passed into the task at execution time. ### The Agent's Execution Details An [agent's execution sessions](/docs/agent-builder/agent-run-logs#the-agent’s-execution-sessions) are labeled with: 1. when the execution succeeds, 2. when it fails. 3. - [The agent's interactive sessions](/docs/agent-builder/agent-interactive-mode). This visual distinction helps you quickly identify the type and outcome of each session. 4. - Indicates that 'Continue Last Session" is enabled for the agent step, meaning it is part of a multi-task agent session. In the Run Log Panel on the left-hand side is a list of all agent execution sessions. Each session entry includes: * Session ID * Execution timestamp (`HH:MM:SS am/pm`) * Execution status * Triggered by (manual or automated) * Parent workflow name (if applicable) * User name (for test runs) * Test run label (if applicable) * Multiple Tasks (If applicable)- A multi-task session indicator makes it easy to distinguish continued agent runs from standalone runs. When Continue Last Session is enabled, the agent continues the previous session within the same workflow run. This allows it to retain context from earlier tasks rather than starting a new session, creating a multi-task agent session. *** In the top-right corner of the **Run Logs** page, you will find key execution details, including: * The total duration of the selected run * The total amount of processed data used during execution * The agent version used — click the version link to view the corresponding [Agent's configuration details](/docs/agent-builder/building-the-agent#creating-a-new-agent): *** # Agent Usage Tracking Source: https://docs.blinkops.com/docs/agent-builder/agent-usage-tracking Track agent usage metrics and monitor activity through the Agent Tracking Dashboard in Blink. **Note**: Only users with the [Tenant Admin](/docs/blink-platform/account-management/roles#1-admin) role have permission to access this Dashboard In the [Tenant Dashboard](/docs/blink-platform/workspaces/monitoring-workspaces), the **Agents** tab provides access to the **Agent Tracking Dashboard**. This dashboard gives you a comprehensive view of agent activity across your tenant and workspaces. It highlights how agents are being used, tracks data processing, and surfaces usage trends over time. With this visibility, you can effectively track agent usage, optimize resource allocation, and ensure you stay within your quota limits. With this dashboard, it can help you: * Track total data processed by agents across your tenant. * See how many agents are active and in use. * Measure executed tasks and data trends over time. *** ## Automatic Quota Threshold Alerts Email notifications are sent to all [tenant admins](/docs/blink-platform/account-management/roles#1-admin) at the following thresholds: * **50%** * **75%** * **90%** * **Blocked** (when the tenant’s licensed data quota has been reached) A **warning alert** is displayed when you reach **50%** and more of your tenant’s data processing quota. This becomes a critical alert when **90%** of the licensed data is exceeded. **For Example:** *** ## Tenant Summary
| | Title | Description | | ----- | ------------------------ | ---------------------------------------------------------------------------------------------------- | | **1** | **Tenant Data Usage** | Total data processed by agents across all workspaces in your tenant out of the total licensed quota. | | **2** | **Tenant Active Agents** | Number of enabled agents available across all workspaces in this tenant. | | **3** | **Tenant** | Dropdown to filter and view agent data specific to a selected tenant |
*** ## Agent Usage Analytics - Across All Workspaces
| | Title | Description | | ----- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | | **4** | **Timeframe** | Allows you to define the timeframe for the data displayed (e.g., last 7 days, last 30 days). | | **5** | **Data Processed by Agents (across all workspaces)** | Total data processed by agents in the selected time period. | | **6** | **Agents Used (across all workspaces)** | Number of agents that ran at least once in the selected time period | | **7** | **Executed Agent Tasks (across all workspaces)** | Total number of times an agent task was executed in the selected time period. | | **8** | **Agent Data Processed Over Time (across all workspaces)** | Trend of data processed by agents over the selected time period. Helps visualize usage patterns and peaks | | **9** | **Workspace Usage Summary** | Shows agent activity and data usage per workspace for the selected time period. |
*** # Micro-Agents Vs. Deterministic Workflows Source: https://docs.blinkops.com/docs/agent-builder/agent-vs-deterministic-workflows Understand the differences between AI agents and deterministic workflows, and when to use each approach. Agents bring reasoning capabilities that allow automation to handle ambiguity and change, while deterministic workflows provide reliability for structured, repeatable, and rule-based tasks. Today's automation can combine both: agent steps excel at interpretation, decision-making, and unstructured data, whereas deterministic steps ensure consistency and speed. However, agents still face some constraints, including hallucinations, higher cost, execution limits, and maintenance challenges. To mitigate this, micro agents focus on narrow, well-defined tasks and integrate with Blink’s deterministic workflows. This hybrid approach delivers reliable execution, controls cost by using agents selectively, preserves performance through fast deterministic steps, and simplifies maintenance with safer debugging and updates. The following sections provide guidance on when to use agents so you can design workflows that are both effective and efficient. ## When to use Micro-Agents in Workflows ### 1. Reasoning & Summarization Ideal to use when the task requires interpretation or synthesis of complex information. Unlike deterministic workflows, which follow fixed rules and outputs, Micro-Agents are used when a workflow requires reasoning, analysis, or summarization. They can process unstructured or complex information and generate meaningful insights that the workflow can then use for follow-up actions. **Workflow Breakdown:** 1. **Trigger:** An incident is raised and the investigation workflow begins. 2. **Micro-Agent Task:** * The agent reviews the incident timeline, log entries, and enrichment data. * It identifies key events, interprets patterns, and summarizes findings in natural language. * The agent suggests potential remediation steps (e.g., isolate endpoint, block IP, reset credentials). 3. **Follow-up Workflow Action:** * The workflow takes the agent’s summary and automatically adds it to the Case Management ticket as the analyst’s notes. * This ensures structured documentation of the incident while keeping human analysts in the loop. 4. **Outcome:** * The workflow blends automation with reasoning: repetitive tasks remain automated, while the Micro-Agent provides human-like interpretation and actionable recommendations. ### 2. Unstructured / Ambiguous Inputs Ideal to use for handling messy or unfamiliar input structures (such as incoming logs or alert payloads), especially when specific data must be extracted from new or unexpected formats. When the structure is already known, a deterministic workflow is recommended to ensure accuracy and consistency. Micro-Agents are particularly valuable when workflows need to interpret or extract meaning from unstructured or inconsistent inputs. Unlike deterministic workflows, which rely on a clean schema and fixed mappings, Micro-Agents can adapt to varied formats and return usable, structured data for the workflow to act on. **Workflow Breakdown:** 1. **Trigger:** A new alert or log payload is ingested into the workflow. 2. **Format Check:** * The workflow evaluates the type and format of the payload. * If the format matches an existing schema, the workflow proceeds with a deterministic path designed for that specific fixed input. * If the format is unknown, inconsistent, or ambiguous, the payload is routed to a Micro-Agent. 3. **Micro-Agent Task (for unknown/unstructured inputs):** * The agent scans the payload, even if it is messy, inconsistent, or deeply nested. * It extracts the relevant field (e.g., an IP address), whether it appears as `src_ip`, `ip_address`, or buried in nested JSON. * The agent outputs the extracted IP(s) in a clean, standardized format. 4. **Follow-up Workflow Action:** * The workflow consumes the standardized IP address from either the deterministic workflow or the Micro-Agent. * Example: block the identified IP across the firewall or EDR platform. 5. **Outcome:** * Known formats are processed quickly and accurately through deterministic workflows. * Unknown or inconsistent formats are still usable thanks to the adaptive capabilities of Micro-Agents. *** ### 3. Exploratory / Open-Ended Work Ideal to use when steps are not predefined or the workflow may branch in different directions. Micro-Agents can perform correlation and reasoning across different systems, making them ideal for investigations that require connecting signals from multiple sources. Unlike deterministic workflows that rely on predefined fields, the agent can interpret varied log formats and synthesize findings into a meaningful assessment. **Workflow Breakdown:** 1. **Trigger:** A suspicious login event is detected (e.g., unusual location, time, or behavior). 2. **Micro-Agent Task:** * The agent collects and reviews logs across identity providers (Okta, Azure AD, Google Workspace) and endpoints. * It correlates the login activity with endpoint events (e.g., device posture, EDR signals). * The agent determines whether the login pattern suggests a possible account compromise. 3. **Follow-up Workflow Action:** * The workflow appends the agent’s investigation summary to the Case Management record. * If compromise is likely, trigger automated containment actions (e.g., force MFA reset, block session). 4. **Outcome:** * The agent provides human-like investigation capabilities, surfacing insights from multiple noisy data sources. * The workflow ensures those insights are immediately actionable and documented. ### 4. Contextual Decision-Making Ideal to use when a process requires evaluating tradeoffs or choosing the best next step from several options. Micro-Agents are ideal when workflows require more nuanced, context-aware decisions instead of relying on rigid thresholds. They can weigh multiple signals together and reason about the likelihood of malicious activity, enabling more accurate outcomes than simple rule-based checks. **Workflow Breakdown:** 1. **Trigger:** A login event is detected. 2. **Micro-Agent Task:** * The agent evaluates **multiple contextual signals** including: * User behavior patterns * Device posture * Login time and location * Text from related logs * Instead of a binary threshold (e.g., `x > 0.9`), the agent reasons about the combination of factors and determines whether the login is suspicious. 3. **Follow-up Workflow Action:** * If suspicious, flag the login and create a Case Management entry or force MFA challenge. * If benign, allow the workflow to continue without escalation. 4. **Outcome:** * The workflow benefits from context-aware decision-making, reducing false positives while still catching true anomalies. ## When to use Fully Deterministic Workflows ### 1. Well-Defined, Structured Processes Ideal to use when the task can be fully described as a fixed sequence of steps with clear inputs and outputs. This workflow ensures that whenever a high-severity alert is raised, a Jira ticket is automatically created with consistent fields, reducing manual effort and maintaining compliance. **Workflow Breakdown:** 1. **Trigger:** High-severity alert occurs in the system. 2. **Data Extraction:** Capture alert details (name, source system, timestamp, description). 3. **Ticket Creation:** Automatically populate Jira fields: * Project: Security Incidents * Issue Type: Bug/Incident * Priority: Highest/Blocker * Summary: `High-Severity Alert: [Alert Name]` * Description: Alert details and context 4. **Notification (Optional):** Notify security team via Slack or email. 5. **Logging:** Record alert ID and ticket ID for traceability. **Outcome:** Every high-severity alert consistently produces a properly formatted Jira ticket. ### 2. Clear, Rule-Based Decisions Ideal to use when the logic can be expressed through strict conditions or thresholds. This workflow automatically performs remediation actions whenever a detection confidence exceeds a defined threshold, ensuring predictable and repeatable outcomes. **Workflow Breakdown:** 1. **Trigger:** Alert is detected. 2. **Evaluate Condition:** Check if `Detection Confidence > 0.9`. 3. **Remediation Actions:** Automatically execute predefined actions such as: * Isolating affected systems * Blocking malicious IPs or users * Quarantining suspicious files 4. **Logging:** Record all remediation actions for auditing. **Outcome:** High-confidence alerts are handled automatically, minimizing response time and human error. *** ### 3. High-Volume, Cost-Sensitive Workflows Ideal for tasks that run frequently and must remain efficient and low-cost. This workflow enriches every incoming alert with additional context from threat intelligence and geo-IP data, enabling consistent analysis while remaining efficient. **Workflow Breakdown:** 1. **Trigger:** Runs automatically for every incoming alert. 2. **Data Extraction:** Capture fields such as source IP, domain, or alert type. 3. **Enrichment Actions:** Query threat intel sources and perform geo-IP lookups. 4. **Attach Enrichment Data:** Add structured enrichment fields (e.g., Threat Level, Malware Family, Country of Origin). 5. **Logging:** Track enrichment actions for traceability and prevent duplication. **Outcome:** All alerts are consistently enriched, supporting faster investigation and decision-making. *** ### 4. Predictable & Consistent Outcomes Ideal to use when outcomes should always follow the same fixed sequence. This workflow ensures that user offboarding always follows the same fixed sequence, removing access to systems in a predictable and auditable way. **Workflow Breakdown:** 1. **Trigger:** User offboarding event is initiated (e.g., HR system update). 2. **Disable Okta Account:** Revoke authentication immediately. 3. **Revoke Cloud Credentials:** Remove access to AWS, Azure, GCP, etc. 4. **Remove Slack Access:** Remove from workspace and channels. 5. **Logging:** Ensure all actions are recorded and the sequence is strictly enforced. **Outcome:** Users are offboarded securely, consistently, and without risk of skipped steps. *** ### 5. Structured Data and Clear Schemas Ideal to use when inputs and outputs follow a stable, well-defined structure that the workflow can rely on deterministically. This workflow triggers whenever a new user is added in Okta and automatically provisions them in downstream systems like Salesforce and Slack, ensuring structured data and predictable results. **Workflow Breakdown:** 1. **Trigger:** Okta “New user created” event occurs. Fields include: Email, Name, Role. 2. **Data Extraction:** Capture and validate user details from Okta. 3. **Salesforce Provisioning:** Create the user with correct email, name, and role. 4. **Slack Provisioning:** Create the user in Slack with correct workspace access and channels. 5. **Logging:** Record provisioning actions and flag any failures for review. **Outcome:** Every new Okta user is automatically provisioned in multiple systems with consistent and accurate data. *** # Best Practices Source: https://docs.blinkops.com/docs/agent-builder/best-practices Recommended practices for defining, configuring, and optimizing agents built with the Blink Agent Builder. ## Overview The Agents in BlinkOps enable teams to build automation-ready AI agents tailored to their unique roles, environments, and organizational policies. Following the best practices in this guide will help ensure your agents behave consistently, securely, and predictably while delivering reliable outcomes at scale. This guide provides practical recommendations for designing production-ready AI agents in BlinkOps. It covers every stage of agent development, including 1. [Agent Instructions – Crafting Roles & Constraints](/docs/agent-builder/best-practices#1-2-agent-roles-the-core-guardrails-for-prompts) 2. [Abilities (Tools) & Handling Large Outputs](/docs/agent-builder/best-practices#2-abilities-tools-%26-handling-large-outputs) 3. [Knowledge Base (RAG) vs. Direct Context Injection](/docs/agent-builder/best-practices#3-knowledge-base-rag-vs-direct-context-injection) 4. [Agent Role vs. Agent Task](/docs/agent-builder/best-practices#4-agent-role-vs-agent-task) Whether you are building a new agent or improving an existing one, these best practices will help you create agents that are scalable, maintainable, and optimized for real-world security automation. *** ## 1. Agent Instructions – Crafting Roles & Constraints Ensure that agentic prompts are written as modular code blocks rather than prose, guaranteeing predictable runtime execution and seamless integration into larger Blink playbooks. ### 1.2 Agent Roles- The Core Guardrails for Prompts **Rule 1: Use Structured XML Tags for Section Boundaries** Models powering advanced agentic security thrive on structural syntax. Avoid mixing behavioral rules with role definitions or leaving instructions floating as loose paragraphs. Wrap every logical block in named XML tags. This creates clear semantic boundaries and prevents instruction bleeding. **Example:** Use the schema below for custom agents built in Blink. ```xml theme={"dark"} Define WHO the agent is, its core domain, and its operational boundaries. Explain WHY this agent is running and what ecosystem it sits within. Define HOW the agent thinks, its epistemic standards, and its approach to uncertainty. Hardcode the exact tools the agent MUST run before delivering an answer. The final self-verification checklist executed at runtime. ``` *** **Rule 2: Shape the Reasoning with a `` Block** A `` block is what separates an agent that technically answers correctly from one that consistently reasons the right way in high-pressure security situations. Use it to explicitly define the agent's tone, evidence threshold, output verbosity, and how it handles ambiguity or gaps in data. * Do not just say "be accurate." Define the evidence-driven threshold. * Enforce negative constraints explicitly (e.g., forbidding speculation on attribution without specific indicators). **Example:** ```xml theme={"dark"} - Be evidence-driven, analytical, and highly concise. - Do not speculate or infer facts not explicitly supported by the data provided. - Do not dismiss findings solely because a single indicator looks benign. - Consider cumulative evidence—never evaluate security indicators in isolation. - If evidence is incomplete, reflect that uncertainty in your confidence scores but still provide the best-supported analysis. - Do not reveal your chain-of-thought in the final payload response. ``` *** **Rule 3: Implement a `` as Part of the Agent Constraints** The `` is a self-verification checklist that the agent evaluates before finalizing its output payload. It can catch missing tool calls and formatting errors before they ever reach an end user. * Write items as binary pass/fail conditions. * Mirror constraints: if a tool call or rule is mandatory elsewhere in the prompt, it must have a matching verification item in the quality bar. * **Placement:** Always place the `` tag at the end of the "Constraints" field so it executes last. **Example:** ```xml theme={"dark"} Before returning output, verify and ensure: - All tools specified in were called before generating the answer. - No analyst triage question was left unaddressed. - The output strictly adheres to the JSON format defined in the output schema. - No answer contains speculation, assumptions, or unsupported inferences. ``` *** **Rule 4: Use Booleans or Star Scales for Structuring LLM Decisions** When an agent is responsible for risk scoring, alert classification, or tier ranking, never rely on the LLM to do "mental math" (e.g., multiplying numbers or calculating formulas) or natural "vibe" checks. LLMs cannot guarantee implicit mathematical logic. Instead, force the LLM to evaluate specific, deterministic criteria using Booleans (True/False) or a strictly defined 1–5 Star Scale. Any final score composition, math, or complex branching logic should be handled downstream in Blink Automation steps or Python code. **Recommended: The Boolean Checklist Approach** The most reliable way to score with an LLM is to ask for a series of True/False assessments, then calculate the final score outside the LLM. **Example:** ```xml theme={"dark"} Evaluate the security alert and respond with TRUE or FALSE for each of the following criteria: 1. IS_PROD: Is the affected asset a production environment? 2. EXPLOITED: Is there active evidence of exploitation in the wild? 3. PRIVILEGES: Does the attacker have administrative or root access? 4. SENSITIVE_DATA: Does the asset contain PII, financial data, or credentials? ``` Pass these boolean outputs into a Blink Automation or Python step to calculate the final tier (e.g., if 3 or more are TRUE, escalate to Critical). **Alternative: The Explicit 1–5 Star Scale** If you cannot use booleans, use a 1–5 scale where every single tier is explicitly and rigidly defined. Do not let the LLM guess what a "3" means. **Example:** ```xml theme={"dark"} Assign a severity score from 1 to 5 based strictly on the definitions below: 1 - Low: Informational alert, no evidence of compromise, non-prod asset. 2 - Minor: Anomalous behavior detected on non-critical asset; isolated incident. 3 - Medium: Potential compromise of a standard user account or non-prod server with no data exfiltration. 4 - High: Confirmed compromise of a corporate asset or production service; potential data access. 5 - Critical: Confirmed compromise of a Domain Controller, core database, or executive account; active data exfiltration. ``` *** ### 1.2 Agent Task: Inputs & Runtime Constraints **Rule 5: Inject Dynamic Context via ``** When an execution requires dynamic validation data that changes on every run (e.g., dynamic allowed closing reasons, authorized asset lists, user risk scores), do not hardcode them into the global prompt. Use the runtime dynamic constraints field. The injected content must mirror the XML structure to seamlessly bind with the base prompt logic: **Example:** ```xml theme={"dark"} ={{ conclusion_summary }} ``` *** ### 1.3 Agent Task: Output Schemas **Rule 6: Define Output Schemas as Annotated JSON Examples** To guarantee predictable hand-offs to downstream tables, dashboards, and automated case management systems, the output format must be zero-ambiguity JSON. **Important notes:** * Do not use type names (like `"string"`, `"int"`, or `"float"`) or descriptive ranges (like `"0-100"`) inside your example values. The schema builder interprets your values literally — if you write `"float"`, the system will expect a literal text string of `"float"`. Instead, use actual, valid sample data to dictate the type. * Don't stress too much about strict string-to-number validation for downstream steps. Blink includes built-in type coercion: if the LLM outputs a number wrapped as a string (like `"36.5"` or `"0"`), Blink will automatically convert it to a true number when passing it into the next automation input. **Key guidelines:** * **Strings:** Provide a realistic sample text string (e.g., `"Suspicious activity detected"`). * **Numbers:** Provide a literal valid number (e.g., `1` for integers, `3.5` for floats). * **Enums:** Use an explicit, human-readable instruction followed by comma/pipe-separated values (`|`) to strictly define allowed choices. * Include reference to parameters. **Example:** ```json theme={"dark"} { "summary": "[brief_summary_of_why_the_ip_is_flagged_or_not]", "intent": "Must be one of the following: Malicious | Benign | Duplicate | Inconclusive", "risk": { "risk_score": 85, "risk_severity": "Must be one of the following: Low | Medium | High | Critical" }, "closing_reason": "Must be one of the following: Escalated | Automatically resolved | False positive | Duplicate | No action needed", "closing_reason_confidence_score": 0.95 } ``` ### 1.4 Modular Prompting with Agent Skills `[UPCOMING]` When an agent is augmented with Skills, the core prompt layout must change. If you hardcode tool-specific instructions into the main prompt while dynamically attaching and detaching skills, the agent's context will become misaligned, leading to execution failures or ignored tools. **The Architectural Shift: Monolithic vs. Skill-Based** * **Old Way (Monolithic):** The agent prompt contains the role, the behavior, and detailed instructions for every tool it might use. * **New Way (Skill-Based):** The agent prompt contains only the operational kernel (core identity, reasoning standards, and a coordination routing framework). The specific context, constraints, and execution parameters for a capability live inside the Skill definition itself. **Strip Specific Tool References from the Core Prompt** Do not mention specific tools or data formats (e.g., "Use the CrowdStrike containment ability") in the main `` or `` blocks. Instead, instruct the agent to leverage its active skills catalog dynamically. \*/} *** ## 2. Abilities (Tools) & Handling Large Outputs Design agent workflows and tool interfaces that execute deterministically, never crash the LLM context window with massive data payloads, and optimize the "Machine-to-Human" hand-off. ### 2.1 Designing Agent Abilities When building Blink workflows that expose as "Abilities" (tools) to an agent, you must ensure the agent understands exactly when, why, and how to call them. When an agent evaluates whether to run a workflow, it only receives the Name and Description of the workflow — it does not see the full underlying YAML or configuration. Because of this limited visibility, your metadata must provide absolute clarity for the agent's routing logic. **Important notes:** * **Provide sufficient context:** Ensure the name and description explicitly state what the workflow does, what it requires, and when it should be used so the agent can accurately decide if it's the correct tool for the job. * **Call out side-effects:** If a workflow performs a disruptive or state-changing action (e.g., blocking an IP, disabling a user account, or sending an external notification), you must explicitly state this side-effect in the name or description. This prevents the agent from accidentally triggering high-impact actions during passive analysis. If an agent's success depends on running a specific tool, regardless of how the user's input looks, do not leave it up to the agent's discretion. Explicitly enforce it by its exact execution name inside a `` block, and mirror it as a binary pass/fail condition in your ``. **Example:** ```xml theme={"dark"} You MUST execute this ability before finalizing your analysis: - get_vip_users: Retrieves the organization's high-risk/VIP user list to cross-reference asset ownership. ``` **Important Guardrail**: While the `` block heavily biases the agent to use the tool, LLM orchestration is never 100% guaranteed to trigger it. If your workflow requires absolute, deterministic execution of a tool every single time, do not rely on the agent to make the call. Instead, hardcode that tool execution directly as a native step inside your Blink workflow before or after the agent runs. ### 2.2 Handling Large Outputs & Context Window Mitigation The biggest architectural failure mode in agentic SecOps is letting a tool dump a 50MB firewall log, a massive JSON cloud trail, or a giant vulnerability scan straight into the agent's context window. This causes token saturation, skyrockets costs, destroys processing speed, and induces model hallucinations. Here are the two mandatory engineering design patterns to handle heavy data processing: **Pattern A: Deterministic/Agentic Pre-Filtering Pattern**: Never pass raw, unfiltered dumps downstream. Force the tool or an intermediate code block to apply the tightest filter possible before the data hits the agent. 1. **Deterministic filtering:** * Use optimized platform utilities (JQ or explicit API server-side filtering parameters) to extract only relevant keys or anomalous rows. * Always prioritize inputs that fit natural human reasoning over raw system formats. For example, design the tool to accept a human-readable timestamp (e.g., `"2026-06-29"` or `"2 hours ago"`) rather than a raw Epoch timestamp (e.g., `1782741741`). While an LLM can sometimes convert time, it is highly prone to hallucination and mathematical errors when dealing with unix timestamps. It is always better to design the ability to accept clean, readable strings, and handle the necessary technical conversions (like translating text to Epoch) in the very first step of your underlying workflow. 2. **Agent-guided filtering:** * Turn on ability compaction — it simplifies lengthy or detailed results from the ability, allowing the agent to focus on the most important information. In addition, provide compaction instructions to help the agent decide what's important in this ability's results. * Let a fast, cheap model parse a subset of lines to isolate the exact timestamps or signatures required before passing the clean block to the core reasoning agent. **Pattern B: Agent-Generated Workflows (Offloaded Execution)** Agent-generated workflows are a powerful feature that lets agents move beyond their preconfigured ability list. Instead of relying only on pre-built workflows, the agent can dynamically choose to generate and execute its own Blink workflows, bound to Python and JQ code along with its active abilities as subflows on the fly. By offloading heavy data processing to Blink's secure, isolated execution engine, the agent can handle massive datasets without cluttering its context window or wasting tokens. Essentially, agents can build their own specialized tools right when they need them. **Use cases:** 1. **Advanced Math & Analytics ("No Mental Arithmetic")** * *The problem:* When tasked with complex calculations (e.g., Quarter-over-Quarter growth, financial forecasting, or statistical analysis), LLMs often struggle with precision or hallucinate numbers when doing math "in their head." * *The solution:* The agent extracts the raw data and dynamically generates a Python script to perform the exact calculation. It treats the LLM as the strategist and the Python engine as the calculator, ensuring 100% mathematical accuracy. 2. **High-Volume Data Filtering & Extraction ("Context Slimming")** * *The problem:* A tool returns a massive payload — like thousands of raw log lines or an entire database dump — but the agent only needs a fraction of it. Passing all that data into the agent's context window blows through tokens and increases cognitive load. * *The solution:* The agent writes a precise JQ query or Python script to filter, slice, and extract only the relevant data points before they hit the context window, keeping the agent lean and fast. 3. **Multi-Source Data Cross-Checking ("Hard Joins")** * *The problem:* Correlating disparate data sets (e.g., joining an IT incident log with office badge-in times and asset owner databases) requires tracking complex relationships that easily overwhelm an LLM's memory. * *The solution:* Instead of trying to "hold the data in its head," the agent builds a custom script to programmatically merge and cross-reference the data sources, outputting only the final, correlated insight. 4. **Bulk Execution & Loop Unrolling ("Overcoming Rate Limits")** * *The problem:* An agent has a static ability to perform a single action (e.g., Send Slack Reminder), but it needs to perform that action 100 times. Running 100 consecutive tool calls will hit platform limits, time out, or drain tokens. * *The solution:* The agent adapts by writing a new, bulk-ready ability on the fly (e.g., Send Bulk Slack Reminders). It takes the full list of 100 users as a single input, executes the loop securely in the background, and resolves the task in a single tool call. 5. **High-Volume Templating & Generation ("Heavy Lifting Delegation")** * *The problem:* The user needs a large, heavily structured output where only a small part is dynamic (e.g., a massive HTML email template or a structured JSON payload where only a few variables change). Making the LLM generate the entire static block is a waste of tokens. * *The solution:* The agent crafts the core dynamic content, then writes a quick automation script to inject that content into the larger static template. The agent only "thinks" about the meaningful parts, while the engine handles the boilerplate. *** ## 3. Knowledge Base (RAG) vs. Direct Context Injection Determine whether supporting operational data belongs in a Vector Database (RAG) or injected directly into the active context window. ### 3.1 The Core Dilemma: Search vs. Certainty An LLM cannot act on what it cannot see. Automation engineers often assume that uploading a massive 50-page Incident Response (IR) manual into an agent's Knowledge Base (VectorDB) means the agent "knows" the manual. This is a critical misconception. A VectorDB relies on semantic top-k retrieval (chunking text and pulling the closest matches). It does not guarantee the model reads the entire document, nor does it guarantee it retrieves the correct block of step-by-step instructions when a high-severity alert fires. ### 3.2 When to Use a Knowledge Base (VectorDB) A Knowledge Base is designed for supporting information, reference material, and historical lookups. It is not a substitute for the agent's core operating manual. **Ideal use cases:** * **Massive corp data / historical logs:** Large repositories of past threat intelligence reports, internal asset vulnerability contexts, or extensive corporate network architecture documentation. * **Payloads > 15–20KB:** High-volume data that would completely bloat the prompt, degrade model performance, and spike runtime token costs if included on every single execution. If a dataset qualifies for the Knowledge Base, the data must be cleanly structured and curated. * ✅ **Good practice:** Well-formatted Markdown is excellent for this. * ❌ **Bad practice:** Low-effort "dumps," such as copy-pasting raw text straight from a website alongside a bunch of unrelated navigation garbage, ads, or footers, will severely degrade embedding quality. Take the time to strip out the noise so the agent only processes highly relevant text. ### 3.3 When to Avoid a KB: The Case for Direct Context Injection If the payload size of your instructions, guidelines, or operational rules is less than a few kilobytes (KB), skip the knowledge base entirely. Inject it directly into the prompt context via the ``, ``, or `` fields. **Direct context is mandatory for:** * **The core playbook/manual:** The exact, sequential steps an agent must follow during an active incident (e.g., Phishing Triage Guidelines). * **Deterministic execution:** Any instruction where missing a single step or constraint means an operational failure. Direct context guarantees the model processes the rule on every single run. * **High-context tools:** When an LLM evaluates a specific alert and asks itself, "How do I respond to this phishing attempt?", a KB search might retrieve irrelevant historical phishing files. Direct context instead enforces immediate execution of your designated `block_sender` tool logic. ### 3.5 Quick-Reference Framework: VectorDB vs. Direct Context | | VectorDB (Knowledge Base) | Direct Context Injection | | ------------ | ----------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | | **Pros** | Conserves token windows; scales to gigabytes of data; keeps execution costs lower for vast datasets. | 100% deterministic rule adherence; no retrieval misses; model retains full view of sequential steps. | | **Cons** | Non-deterministic retrieval; risk of missing vital steps; formatting and semantic chunk boundaries can blind the agent. | Bloats prompt size; increases token costs per run; doesn't scale past the model's context limit. | | **Use when** | Data is large reference material (e.g., historical indicators, query language PDF guide). | Data is "the operational manual" or short, strict step-by-step triage constraints. | *** ## 4. Agent Role vs. Agent Task Establish a clean separation of concerns between an agent's compile-time identity (Role) and its runtime execution orders (Task). This helps reduce the odds of prompt drift and enables agent reusability. ### 4.1 The Separation of Concerns: Static Identity vs. Dynamic Execution A frequent architectural mistake when deploying agents in Blink is blending who the agent is with what the agent is doing right now. When you hardcode case-specific instructions into the core prompt, you destroy the agent's reusability and force your team to build a new agent for every single workflow permutation. To build a scalable platform, you must enforce a strict boundary: * **The Agent Role (the identity):** This is the compile-time configuration. It defines the agent's domain expertise, behavioral constraints, reasoning frameworks, and tool boundaries. It is permanent, generic to the domain, and wrapped in standard XML tags (``, ``). * **The Agent Task (the mission):** This is the runtime instantiation. It defines the specific ticket, alert, data artifact, or objective the agent must process during this specific execution cycle. It is transient, injected dynamically. ### 4.2 Designing the Boundary in Blink Workflows When constructing the automation pipeline, the core prompt remains pristine and untouched. The specific workflow context is passed dynamically at runtime using the input parameters. 1. **The core agent configuration (the Role)** — The prompt template defines the persona and how it processes tasks, using a generalized placeholder to ingest the runtime mission (see [Agent Roles](/docs/agent-builder/best-practices#1-2-agent-roles-the-core-guardrails-for-prompts) for more information). 2. **The runtime injection (the Task)** **Example:** When a high-severity AWS GuardDuty alert triggers a Blink workflow, the playbook injects the specific case details and the unique atomic goal into the execution block: ```xml theme={"dark"} OBJECTIVE: Evaluate the attached CloudTrail snippet for potential session hijacking on the user 'admin-ci-cd'. REQUIRED OUTPUT ACTIONS: - Check if the source IP has historically performed successful auth actions. - Determine if the user's active session should be revoked. - Populate the output schema with your risk recommendation. ``` # Building a New Agent Source: https://docs.blinkops.com/docs/agent-builder/building-the-agent Step-by-step guide to creating a new agent using the Blink Agent Builder interface. This section walks you through the process of creating a new agent using the Agent Builder. Each step in the builder helps define the agent's identity, responsibilities, and operational capabilities. By the end of this process, your agent will be configured and ready to use within the Blink Ops platform. To learn more about how the Agent Builder works, click [here](/docs/agent-builder/how-it-works) *** ## Creating a New Agent **Disclaimer** The images shown in this documentation are for visualization purposes only. The appearance and configuration of your agents may differ based on your workspace settings, custom roles, and individual agent configurations. Navigate to the 'Agents' page in your workspace, then click the New Agent button located in the top-right corner of the page. Start by providing a name and title for your agent. You can also include an optional description. A clear and concise description helps other users quickly understand the agent’s purpose and how it is intended to be used. This description also appears in the builder editor as the action label, making it easier to identify the agent during workflow design. Customize your Agent's appearance by choosing a style, color and upload your custom logo. ### Enabled Mode By default, each agent has the 'Task Mode' enabled. Optionally, users can enable 'Interactive Mode', which allows real-time conversations with the agent. 1. **Task Mode** Add the agent to automated workflows to perform specific tasks, respond to triggers, and interact with other systems. Available to all agents by default. By default, task mode is always enabled and locked- it can never be disabled For more information about 'Task Mode' visit [Step 3 of Using the Agent in Workflows](/docs/agent-builder/building-the-agent#using-the-agent-in-workflows). 2. **Interactive Mode** You can interact with the agent through Interactive Mode in: 1. **Test** – Interact with and test the draft version of the agent while building it, allowing you to validate responses in real time. 2. **Start** – Interact with the agent's published version through the chat interface. For more information, visit the [Interactive Mode](/docs/agent-builder/agent-interactive-mode) section of the documentation. 3. **Agent Generated Workflow** Agent-Generated Workflows enable agents to dynamically create and execute Blink workflows at runtime, extending their capabilities beyond their predefined set of abilities. During task execution, the agent continuously evaluates the work required to fulfill a request. For straightforward operations, it invokes its existing abilities directly. When the task requires complex data transformation, iterative processing, custom logic, or handling large datasets, the agent can determine that generating a dedicated workflow is a more efficient execution strategy. **Note**: For more information, visit the [Agent Generated Workflows](/docs/agent-builder/agent-generated-workflows) section of the documentation. ### Roles and Constraints Define the agent’s role within your environment, including its primary responsibilities and any operational constraints it should follow. This helps shape how the agent behaves and interacts with your systems. Use this section to define any boundaries or constraints the agent should follow—what it should not do. This helps guide the agent’s behavior and ensures it operates within the expected limits of your environment. For more guidance, visit the [best practices](/docs/agent-builder/best-practices#1-agent-instructions-–-crafting-roles-%26-constraints) documentation. For more guidance, visit the [Best Practices](/docs/agent-builder/best-practices#2-abilities-tools-%26-handling-large-outputs) documentation Search and select which workflows the agent is allowed to access and execute. These workflows control the specific tasks the agent can perform and automate on your behalf. By assigning pre-built, secure workflows, you ensure agents can carry out necessary actions without needing direct access to your systems or credentials. * Workflows can also include optional "human in the loop" approval steps, allowing sensitive actions to be reviewed before they are executed. * Interactive Agents support parallel ability execution, enabling multiple abilities to run concurrently. This reduces overall task completion time and can lower token consumption by minimizing the number of agent reasoning iterations. * The agent automatically determines which abilities can execute in parallel based on their defined dependencies, inputs, and outputs. Parallel execution behavior can also be explicitly controlled through agent instructions to enforce concurrent execution for specific abilities. Agent reasoning proceeds only after all required parallel ability executions have completed. * For Interactive Agents, ability execution may include a combination of automatically executed abilities and abilities requiring user approval. If a user submits a new message instead of approving a pending action, only the pending abilities are marked as stale. Previously completed abilities and their execution results remain preserved and available to the agent. In the **Active** tab, you'll find all ability workflows that are currently assigned to the agent. * **Show Packs**: Enable the **Show Packs** option to display the pack associated with each ability workflow, making it easier to identify where each workflow belongs. * **New Ability**: Create a new ability workflow by clicking **New Ability**, entering a name, and selecting the pack where the workflow will be created. * **Pre-approval**: Mark all active ability workflows as pre-approved in a single action. A confirmation prompt is displayed before the change is applied to help prevent accidental updates. * A icon will appear next to all pre-approved ability workflows. **Note**:The Pre-approval setting is only available when [interactive mode](/docs/agent-builder/agent-interactive-mode) is enabled. * **Search and Filter**: Quickly find a specific ability workflow by searching for its name. In the **Library** tab, you can browse all ability workflows available in your workspace. * Easily configure a workflow as an active ability workflow by hovering over the desired workflow and clicking the icon. It will automatically become disabled in the "Library" tab and be added to the Active tab. * View the total number of available ability workflows. * **Search and Filter**: Quickly find a specific ability workflow by searching for its name, or filter the list by pack to display only the workflows you need. * Click the icon to refresh and update all ability workflows Hover over an active ability workflow and: * Click the icon to open the selected ability workflow in the editor. * Click the icon to remove it from the list of active ability workflows. * Select an active ability workflow, then click the icon to open its settings. Here, you'll find key information about the selected ability workflow, including: * **Name** – The name of the ability workflow * **Pack** – The name of the pack it belongs to. * **Description** – A description of the ability workflow’s purpose. * **Allow interactive agent execution without approval**- When enabled, This ability will run without asking for confirmation. Applies only to agents that have 'Interactive Mode' enabled. * **Enable response compaction** – A toggle that, when enabled, simplifies lengthy or detailed results from this ability, allowing the agent to focus on the most important information. Enable this if the workflow often returns large amounts of data. * **Compaction Instructions**- Optional notes to help the agent decide what’s important in this ability’s results. It is recommended to provide such instructions, but you can leave this empty if you are not sure. Upload documents for the agent to reference. These materials help the agent better understand your environment, respond more accurately, and make context-aware decisions. See all supported document formats by [visiting this section](/docs/agent-builder/limitations#knowledge-file-upload-limitations). For more guidance, visit the [Best Practices](/docs/agent-builder/best-practices#3-knowledge-base-rag-vs-direct-context-injectionssss) documentation Users with `view-only` permissions will not be able to edit files in the knowledge configuration. To view more knowledge limitations, refer to the [Limitations](/docs/agent-builder/limitations#knowledge-file-upload-limitations) section of the documentation. **Note**: All files are securely uploaded to Amazon database. If a file is removed from the knowledge base or the agent is deleted, all associated data is permanently deleted. **Note**: Knowledge sources are not currently supported when using [Amazon Bedrock as the AI provider](/docs/blink-platform/account-management/ai-settings#configuration-amazon-bedrock-as-the-ai-provider). Knowledge functionality is available only when using [Blink as the AI provider](/docs/blink-platform/account-management/ai-settings#ai-models). Once all required sections are completed, click the 'Publish' button in the top-right corner to deploy your agent. A confirmation popup will indicate that your agent was successfully published and is now active within your workspace. When building your agent, your work is automatically saved, so you can stop at any time and keep an unpublished draft version to return to at any time. *** ## Using the Agent in Workflows Once your agent has been created, you can add it to automated workflows to perform specific tasks, respond to triggers, and interact with other systems. This section explains how to integrate your custom agent into a workflow using Blink’s visual workflow editor. Each step outlined below ensures that your agent is properly configured to operate within the defined workflow and fulfill its assigned responsibilities. Navigate to the Workflows tab in your workspace, then either [create a new workflow](/docs/workflows/creating-a-workflow) or open an existing [workflow](/docs/workflows/workflows) where you want to use the agent. Search for the agent you want to include in the workflow. Once located, add it as a step in your workflow. Agent steps are treated like any other workflow step, and you can define their inputs and expected outputs accordingly. Clearly define the agent’s primary task in this step. This sets the context for what the agent is expected to achieve during its execution. Parallel ability execution can be controlled through instructions defined in the Agent task parameter. By explicitly specifying which abilities should run concurrently, agents can execute multiple abilities in parallel. Subsequent agent reasoning begins only after all required parallel executions have completed, helping reduce task completion time and potentially lowering token usage by minimizing agent iterations. In the top-right corner of the agent step's output, click [Agent Configuration](#creating-a-new-agent) to open the Agent Builder's configuration interface. The more context and clarity you provide, the better the agent will perform its task in the automated workflow. For more guidance, visit the [best practices](/docs/agent-builder/best-practices#4-agent-role-vs-agent-task) documentation. You can provide a sample `JSON` output to illustrate the expected structure the response of the agent’s output. This helps with downstream step configuration and validation. If you prefer the response to be plain text, simply leave this section blank. Only one `JSON` output example should be provided. The `JSON` output can support up to `10` levels of nesting, meaning it can include objects or arrays nested inside each other, but only up to three layers deep. To prevent using real data during testing, you can use the [mock output](/docs/workflows/building-workflows/steps#mock-output) feature. This allows you to simulate step results without consuming your tenant’s data quota. ## Phishing Email ```json theme={"dark"} { "operation_explanation": "", "blocked_senders": ["attacker@gmail.com", "attacker2@gmail.com"], "email_subject": "Urgent: Your Account Will Be Suspended!", "provider": "gmail", "malicious_urls": ["http://phishy-link.com/reset"], "actions_taken": [ "sender_blocked", "team_notified"] } ``` ## Security Alert Summary This `JSON` output example provides a structured, human-readable summary of a security alert. It captures what occurred (`alert_summary`), who was involved (`user_summary`), the behavior of the device (`device_summary`), and any suspicious indicators like external `IPs`, `file hashes`, and `URLs`. It concludes with `recommended_actions`—specific steps an analyst should take to investigate or remediate the incident. This format is typically used to enrich alerts and support triage decisions. ```json theme={"dark"} { "alert_summary": "The event involved [DESCRIPTION OF WHAT WAS OBSERVED].", "user_summary": "The alert is associated with a [USER ACCOUNT] flagged for [REASON].", "device_summary": "The [DEVICE] has been observed in performing [ACTIVITY]", "external_ips": "The [IP ADDRESS] has been detected as [DISPOSITION]", "hashes": "The [FILE HASH] was found to be [VERDICT].", "urls": "[The URL] is [VERDICT]", "recommended_actions": "You should do [LIST OF ACTIONS] to resolve this incident." } ``` ## Alert Mapping to MITRE ATT\&CK This `JSON` output example maps alert details to the MITRE ATT\&CK framework, offering standardized fields like `alert_name`, `alert_title`, `source`, and `severity`. Most importantly, it includes a `mitre_mapping` field that ties observed behavior to known adversary tactics and techniques. This format helps analysts quickly understand the nature of the threat and align it with industry-recognized classifications for faster, more informed response. ```json theme={"dark"} { "alert_name": "[ALERT NAME]", "alert_title": "[ALERT TITLE]", "source": "[SOURCE]", "severity": "[SEVERITY LEVEL]", "mitre_mapping": "[TACTIC]:\n- [TECHNIQUE NAME]\n- [TECHNIQUE NAME]\n\n[TACTIC]:\n- [TECHNIQUE NAME]\n- [TECHNIQUE NAME]" } ``` When Continue Last Session is enabled, the agent continues the previous session within the same workflow run. This allows it to retain context from earlier tasks rather than starting a new session, creating a multi-task agent session. In the [Agent's Run Log](/docs/agent-builder/agent-run-logs#run-log-tab-within-the-agent-builder), multi-task sessions are clearly labeled, making it easy to identify when multiple agent runs are part of the same session. Define any additional constraints you want the agent to follow for this specific workflow context. Define the maximum duration (in minutes), the agent is allowed to run before timing out. If the time is exceeded, any running abilities and subflows will stop. To understand how long an agent step is allowed to run and what other execution limits apply, check the full list of constraints in the [Agent Builder Limitations](/docs/agent-builder/limitations) documentation. * **Use Agent Draft Version in Edit Mode**: When enabled, the workflow will run the **draft version** of the agent while in edit mode and during test runs. This lets you test the workflow using the most recent, unpublished changes made to the agent, so you can validate updates before officially publishing them. * **Extend Response Mode** - When enabled, the agent can generate longer responses in a single run. **Note**: It may sometimes lead to more verbose responses. Once all steps are configured, click the 'Publish' button to activate your workflow. Your agent is now live and will execute as defined when the workflow runs. *** ## Manage Portal Settings In the Agents feature, select a specific agent, click the menu, and choose "Manage Portal Access". Then, enter the email address of one or more users or groups within your tenant to share the selected agent in the Blink Portal. *** ## Related Articles Explore a more in-depth explanation of how the Agents work. Follow these best practices to design reliable, safe, and effective security agents using the Agents. Learn more about what to do—and what to avoid. Understand the execution limits, performance constraints, and supported capabilities when building agents. Learn more about what agents can and can’t do. Builder Copilot uses generative AI to help you design custom workflows faster, directly within the Workflow Editor. Learn more about how to use it. *** # Enabling Agents in Your Workspace Source: https://docs.blinkops.com/docs/agent-builder/enabling-agents How to enable the Agent Builder feature in your Blink workspace settings. To begin using Agents in Blink, you first need to enable it in your 'Workspace Settings'. Once enabled, the Agent feature will appear in the left-hand navigation menu, giving you full access to the feature. **Note**: Only users with the [Tenant Admin](/docs/blink-platform/account-management/roles#1-admin) user role have permission to perform this configuration. Click on your initials in the bottom-left corner of the screen to open the settings menu. Then select 'Workspace' to view your available workspaces. You will be directed to your 'Workspace Settings' showing all workspaces you are a member of. Use the search bar to find the specific workspace where you want to enable Agents. Under the Enable Feature column, click the dropdown menu and check the box next to 'Agents' to enable it for the selected workspace. Once enabled, the 'Agent' feature will appear in your left-hand navigation menu. If the 'Agent' feature has not yet appeared in the navigation menu, when enabled, try refreshing the page. # Error Handling Source: https://docs.blinkops.com/docs/agent-builder/error-handling Common errors when working with Blink agents and how to troubleshoot configuration and environment issues. As with any powerful AI automation tool, occasional errors can occur when working with Agents, often due to configuration issues, environment settings, or external dependencies. To help you move past these quickly and confidently, we've outlined the most common errors, what they mean, and how to resolve them. This guide is designed to make your experience with Blink Agents as smooth and productive as possible, even when something unexpected comes up. Below, you will find a list of the most common errors along with suggested remediation steps: ## Rate Limit Errors *"You've reached the maximum number of **requests** allowed for running agents on this tenant. Please try again in `{next_window}`."* This error occurs when the number of agent run requests has exceeded the permitted limit for the tenant within a fixed time window. This request [rate limit](/docs/agent-builder/limitations#rate-limits) ensures fair usage and system stability. Wait `1-minute`, then retry the request. *** *"Rate limit exceeded: 1-minute data processing limit reached. Retry in one minute."* This error indicates that the tenant has consumed the maximum number of agent execution requests within `1-minute` window. Wait `1-minute` to resume execution or review usage patterns. For additional information, navigate to the [rate limits](/docs/agent-builder/limitations#rate-limits) section. *"Rate limit exceeded: 60-minute data processing limit reached. Retry in a few minutes."* This error indicates that the tenant has consumed the maximum number of agent execution requests within the `60 minute` window. Wait a few minutes to resume execution or review usage patterns. For additional information, navigate to the [rate limits](/docs/agent-builder/limitations#rate-limits) section. *** ## Abilities Errors *"The agent exceeded the maximum limit of `20` abilities executions in a single run."* Refine the agent task so the agent processes fewer items in a single run. For example, if the agent is analyzing IP addresses, provide a smaller subset at a time (e.g., batch them in groups of 5–10 instead of sending all 20 at once). This helps keep the number of ability executions within the allowed limit. *** *"Ability execution output is too long. Maximum size allowed is `100KB`."* This error indicates that the output generated after running the agent step exceeded the maximum allowed size of `100KB`. Here’s a rewritten, suitable remediation: Review the ability used in the agent step and adjust how it is configured to generate only the essential data needed for your outcome. This may involve refining prompts and filtering unnecessary detail so the resulting abilities output remains within the `100KB` size limit. *** *"Ability execution failed: `{workflow_name}`. Please try again or contact support if the issue persists."* A specific ability (workflow) failed during execution. This is typically caused by internal processing errors, misconfiguration, or connectivity issues. Check the workflow setup and logs for more details. *** ## Other *"The agent output structure exceeded the supported nesting depth of `3` levels."* The agent's output includes a `JSON` structure nested deeper than three levels, which exceeds the supported depth. To resolve, [simplify the output](/docs/agent-builder/building-the-agent#json-output-format-phishing-email-example) to meet the depth limit. *** *"An unexpected error occurred while running the agent. Please try again or contact support if the issue persists."* An uncaught exception occurred during agent execution. This may be due to an internal runtime issue. Retry the run, and if the problem persists, escalate for further investigation. *** # How it Works Source: https://docs.blinkops.com/docs/agent-builder/how-it-works How the Blink AI Agent Builder works, including agent configuration, reasoning, and execution flow. The No-Code Security AI Agent Builder provides a visual interface for designing and configuring AI agents by defining their role, responsibilities, capabilities, and constraints. Once created, agents are integrated into Blink Ops workflows to automate specific security tasks. These tasks, known as agent actions, are assigned to agents with detailed instructions and expected outcomes. After executing the task, the agent returns a response indicating success or failure. The process of building an agent includes the following steps: 1. **Build an Agent:** Define the agent's name, title, role, and responsibilities. 2. **Configure Abilities**: Select the [workflows](/docs/workflows/workflows) the agent can access and define input parameters. 3. **Define Tasks**: Specify the agent's task within a [workflow](/docs/workflows/workflows), including any specific instructions or constraints. 4. **Deploy and Automate**: Integrate the agent into Blink Ops [workflows](/docs/workflows/workflows) to automate security operations. For a detailed guide on building the agent, click [here](/docs/agent-builder/building-the-agent). *** ## Agent Sessions Agents operate within isolated sessions and begin each one without any memory of previous sessions. During a session, they gather and learn information relevant to the task at hand. A session normally covers a single task, meaning each new agent task execution starts with a fresh session, however, when the session continuity is enabled in an agent step, the agent can continue the same session within the *same workflow execution*, allowing it to reuse context and build on information from earlier steps instead of starting over. *** ## Agent Task Execution Process To perform a task, agents first evaluate their configuration, capabilities, and the task details. They use this context to enrich a call to the LLM provider, which guides their next step: either invoking an ability (i.e., running a workflow) or returning a final response. If an ability is needed, the agent instructs the Blink Workflow Engine to execute the relevant workflow. Once completed, the agent incorporates the results as new context and reassesses the task. This loop continues until the agent concludes that the task is complete and submits a final response. *** ## Key Benefits 1. **Enhanced Automation**: Automate complex security workflows with AI-driven decision-making. 2. **Customizable Logic**: Define agent tasks, constraints, and escalations to align with your security policies. 3. **Increased Efficiency**: Reduce manual effort and free up security professionals to focus on strategic initiatives. 4. **Seamless Integration**: Connect agents to any security tool, service, or API in your environment. 5. **Scalability and Reliability**: Built on BlinkOps' robust automation platform, ensuring enterprise-grade scalability, security, and reliability. *** # Limitations Source: https://docs.blinkops.com/docs/agent-builder/limitations Known limitations and system constraints for agents built with the Blink Agent Builder. ## General Limitations
| Limit Description | Limit Value | Notes | | -------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Maximum size per input | `100KB` |
  • In most cases, the input refers to the output of an ability execution. If this output exceeds the 100KB limit, the agent session will fail and may not respond as expected.

  • **Recommendation:** To avoid exceeding the size limit, workflow builders should transfer only the most relevant information from the ability execution to the agent input. Use workflow outputs to extract and pass concise, essential data
| | Maximum size for an agent executed ability (workflow) final output | `100KB`(default) and`300KB` (When [‘Summarize Long Responses’](/docs/agent-builder/building-the-agent#creating-a-new-agent) setting is enabled) | When the ‘Summarize Long Responses’ setting is enabled ([Step 4.1 of Building an Agent](/docs/agent-builder/building-the-agent#creating-a-new-agent)), the maximum output size for an agent-executed ability is `300 KB`; when the setting is disabled, the maximum is `100 KB`. | | Maximum output size for an agent step’s output (final response) | `40KB` | | | Maximum number of ability executions per agent run | `20` | | | Maximum timeout for an Agent step | `14 days` |
  • The default time out is set to `30` minutes

  • Paused time doesn’t count toward workflow duration.

  • Visit the [Exceptions](#step-level-timeout:exceptions-the-interactive-action-and-the-wait-action) under [More In-Depth Explanation of Timeout Limitations](#more-in-depth-explanation-of-time-limitations) section, for a more detailed breakdown.
| | [Agent Generated Abilities](/docs/agent-builder/agent-generated-workflows) | `5` | If an agent already has 5 agent generated abilities and attempts to generate an additional ability, an error will be displayed indicating that the maximum number of agent generated abilities has been reached. | | | | |
*** ## Agent Depth To prevent infinite loops, the system limits how many agents can call each other in a chain. This limit is known as the **agent call depth**. If more than 5 agents are invoked consecutively, either directly via workflow abilities or indirectly through subflows, the system halts execution and raises an error.
| **Limit Description** | **Limit Value** | **Notes** | | --------------------- | --------------- | --------- | | Maximum allowed depth | `5 steps` | |
**Agent Depth Examples**
| Scenario Description | Agent Call Chain | Allowed? | | ---------------------------------- | --------------------------------------------------------- | -------- | | 5 unique agents | Agent A → Agent B → Agent C → Agent D → Agent E | ✅ Yes | | Same agent called 5 times | Agent A → Agent A → Agent A → Agent A → Agent A | ✅ Yes | | 6 agent invocations (loop pattern) | Agent A → Agent B → Agent A → Agent B → Agent A → Agent B | ❌ No |
*** ## Knowledge - File Upload Limitations Images included in files uploaded to Knowledge are not supported and will be ignored during processing. **Important to Note**: Knowledge sources are not currently supported when using [Amazon Bedrock as the AI provider](/docs/blink-platform/account-management/ai-settings#configuration-amazon-bedrock-as-the-ai-provider). Knowledge functionality is available only when using [Blink as the AI provider](/docs/blink-platform/account-management/ai-settings#ai-models)
| **Limit Description** | **Limit Value** | **Notes** | | ----------------------------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Maximum number of documents that can be uploaded | `10` | | | Maximum file size per document | `50 MB` | Supported document types:
  • `csv`
  • `doc`
  • `docx`
  • `html`
  • `md`
  • `pdf`
  • `txt`
  • `xls`
  • `xlsx`
| | The total amount of knowledge data processed per task | `0.6 MB` | Agents can query the knowledge multiple times per task. |
*** ## Rate Limits
| **Limit Description** | **Limit Value** | **Notes** | | ------------------------------------------------ | ---------------------- | --------- | | Maximum requests per minute (per tenant) | `1600` requests/minute | | | Maximum agent data usage per minute (per tenant) | `5.5` MB/minute | |
# The Agent's RBAC Permissions Source: https://docs.blinkops.com/docs/agent-builder/permissions Role-based access control permissions for managing agents in the Blink platform. ## Overview This table outlines the Role-Based Access Control (RBAC) permissions available for managing agents in the Blink platform. These permissions operate at the **workflow scope**, meaning they control what actions a user can perform on agent configuration and agent-related workflows. Each permission grants a specific level of access or capability and is typically assigned through user roles, which can be scoped to specific resources or environments to ensure precise access control.
| Feature | Description | Permissions | | ------- | ---------------------------------------------------------------- | ------------------ | | Agents | Allows viewing existing agents and their metadata. | `workflow:view` | | Agents | Allows publishing new or updated agents to the platform. | `workflow:publish` | | Agents | Allows editing existing agents, including configuration changes. | `workflow:edit` |
# Key Agent Concepts Source: https://docs.blinkops.com/docs/agent-builder/terminology Key terms and definitions used in the Blink Agent Builder, including agents, abilities, and guardrails. ## General Concepts 1. **AI Agent** (also known as Agents): Agents are a new automation capability within the Blink platform that enables AI reasoning (human-like thinking). Agent reasoning involves goal-directed decision-making that can resemble human-like thinking, but is based on algorithms and data rather than consciousness. 2. **No-Code Agent Builder**: Blink's visual interface for creating and configuring AI agents without writing code. It allows users to define the agent’s purpose, set abilities and constraints, customize the prompt template, and manage interactions using simple English instructions (e.g., “You are a GRC analyst responsible for handling policy violations and escalating critical compliance risks”), all within an intuitive UI. 3. **LLM**: A Large Language Model (LLM) is an AI system trained on large amounts of text to understand and generate human language. It can answer questions, write text, summarize information, and more. *** ## Agent Configuration Concepts 1. **Agent Roles**: User-defined scopes that describe what the agent is responsible for. Roles help shape the agent's behavior and context (e.g., "Customer Support Agent," "Security Analyst Assistant"). 2. **Agent Constraints**: Rules that define what an agent **should not do**. These boundaries limit the agent’s behavior, inputs, or outputs to ensure it operates safely, ethically, and within the intended scope (e.g., “Do not assume intent. Only report what you can observe from the logs” or “Only respond with three sentences”). 3. **Agent Abilities**: The specific actions an agent can perform, implemented via deterministic and secure Blink workflows (e.g., "Hybrid Analysis - Hash Report" or "VirusTotal - IP Address Report"). 4. **Agent Knowledge**: Consists of uploaded files and documents that the agent can reference to enhance its understanding of your environment. These resources enable the agent to provide more accurate responses and make informed, context-aware decisions. 5. **Peer Agents**: Other Blink AI agents that can delegate sub-tasks. They may pass tasks between each other, share context, or operate in sequence to complete multi-step processes across teams or systems. *** ## Agent Run-Time Concepts 1. **Agent Session** - In a session an agent performs a single task or a series of related tasks to complete a specific objective. Agents operate within isolated sessions and begin each one without any memory of previous sessions. During a session, they gather, learn, and process information relevant to the task at hand. 2. **Agent Task**: A specific goal or instruction given by the user to the agent to complete. The Agent tasks are defined in the agent's workflow action and work in conjunction with agent roles and constraints. 3. **Agent Reasoning**: Agent reasoning refers to the interaction between the agent and the large language model (LLM). It represents the internal reasoning, planning, or decision-making process the agent performs before taking an action. 4. **Data Processed**: Data processed refers to the information ingested, analyzed, or transformed by the agent during its task. This includes but is not limited to agent configuration, any inputs from user prompts, or outputs generated during workflow execution. 5. **Agent Operation** - An agent operation refers to a single, discrete execution carried out by the agent, such as running an ability (executing a workflow) or delegating a sub-task to a peer agent. 6. **Agent Output**: The agent's final output for a given task. The format can be either free text or `JSON`, depending on the instructions provided. *** ## Related Articles Best practices for building reliable, scalable, and production-ready micro-agents. # Gets all custom template actions in a workspace Source: https://docs.blinkops.com/docs/api/action-templates/gets-all-custom-template-actions-in-a-workspace get /workspace/{ws_id}/action_template API endpoint to retrieve all custom template actions available in a workspace. # APIs Source: https://docs.blinkops.com/docs/api/api Overview of the Blink API and how to use it to automate and integrate with the Blink platform programmatically. The Blink REST API provides programmatic... The Blink REST API provides programma... 6 items 6 items 2 items 1 item 1 item 5 items 8 items 4 items 2 items 6 items 2 items 1 item 13 items 2 items # List user workspaces Source: https://docs.blinkops.com/docs/api/authorization/list-user-workspaces get /user-workspaces Returns a map of all workspaces the authenticated user has access to # Blink REST API Source: https://docs.blinkops.com/docs/api/blink-rest-api Reference documentation for the Blink REST API, including authentication, endpoints, and usage examples. ## Authentication All requests to the Blink API require authentication. ### Generate an API Key 1. Log in to your BlinkOps account and navigate to the API Keys page. 2. Copy one of the existing API keys or create a new one. 3. Add the generated key to your request headers as BLINK-API-KEY. ### Using an API Key Each request sent to the REST API must be authenticated using an API key, included in the BLINK-API-KEY header. For example: ```shell theme={"dark"} curl -L -X POST 'http://app.blinkops.com/api/v1/playbooks/33168bb7-a395-47c9-ba7a-d44b649940dc/execute' \ -H 'Content-Type: application/json' \ -H 'Accept: application/json' \ -H 'BLINK-API-KEY: h4536jlkh345l456l35y4543l5ls' ``` ## Limits Blink supports a maximum of 1000 records per page. # Create a Case Source: https://docs.blinkops.com/docs/api/case-management/create-a-case post /workspace/{ws_id}/case_management/table/cases API endpoint to create a new case in Blink's case management system. # Create a Task Source: https://docs.blinkops.com/docs/api/case-management/create-a-task post /workspace/{ws_id}/case_management/table/tasks API endpoint to create a new task within a case in Blink's case management system. # Create an Alert Source: https://docs.blinkops.com/docs/api/case-management/create-an-alert post /workspace/{ws_id}/case_management/table/alerts API endpoint to create a new alert in Blink's case management system. # Create an Attachment Source: https://docs.blinkops.com/docs/api/case-management/create-an-attachment post /workspace/{ws_id}/case_management/table/attachments API endpoint to create a new attachment in Blink's case management system. # Create an Observable Source: https://docs.blinkops.com/docs/api/case-management/create-an-observable post /workspace/{ws_id}/case_management/table/observables API endpoint to create a new observable in Blink's case management system. # Delete a Record from Case Management Table Source: https://docs.blinkops.com/docs/api/case-management/delete-a-record-from-case-management-table delete /workspace/{ws_id}/case_management/table/{table}/{id} API endpoint to delete a record from a case management table in Blink. # List Records from Case Management Table Source: https://docs.blinkops.com/docs/api/case-management/list-records-from-case-management-table get /workspace/{ws_id}/case_management/table/{table} API endpoint to list records from a case management table in Blink. # Update a Case Source: https://docs.blinkops.com/docs/api/case-management/update-a-case put /workspace/{ws_id}/case_management/table/cases/{case_id} API endpoint to update an existing case in Blink's case management system. # Update a Task Source: https://docs.blinkops.com/docs/api/case-management/update-a-task put /workspace/{ws_id}/case_management/table/tasks/{task_id} API endpoint to update an existing task in Blink's case management system. # Update an Alert Source: https://docs.blinkops.com/docs/api/case-management/update-an-alert put /workspace/{ws_id}/case_management/table/alerts/{alert_id} API endpoint to update an existing alert in Blink's case management system. # Update an Attachment Source: https://docs.blinkops.com/docs/api/case-management/update-an-attachment put /workspace/{ws_id}/case_management/table/attachments/{attachment_id} API endpoint to update an existing attachment in Blink's case management system. # Update an Observable Source: https://docs.blinkops.com/docs/api/case-management/update-an-observable put /workspace/{ws_id}/case_management/table/observables/{observable_id} API endpoint to update an existing observable in Blink's case management system. # Update Field for Case Management Table Source: https://docs.blinkops.com/docs/api/case-management/update-field-for-case-management-table put /workspace/{ws_id}/case_management/table/{table}/fields/{field} API endpoint to update a field in a case management table in Blink. # Create connection Source: https://docs.blinkops.com/docs/api/connections/create-connection post /workspace/{ws_id}/connections API endpoint to create a new connection to an external service in Blink. # Delete Connection Source: https://docs.blinkops.com/docs/api/connections/delete-connection delete /workspace/{ws_id}/connections/{id} API endpoint to delete an existing connection in Blink. # Edit connection Source: https://docs.blinkops.com/docs/api/connections/edit-connection post /workspace/{ws_id}/connections/{id} API endpoint to edit an existing connection's configuration in Blink. # Gets a Connection by id Source: https://docs.blinkops.com/docs/api/connections/gets-a-connection-by-id get /workspace/{ws_id}/connections/{id} API endpoint to retrieve a specific connection by its unique identifier in Blink. # List connection types Source: https://docs.blinkops.com/docs/api/connections/list-connection-types get /connection_types API endpoint to list all available connection types supported by Blink. # List connections Source: https://docs.blinkops.com/docs/api/connections/list-connections get /workspace/{ws_id}/connections API endpoint to list all connections configured in your Blink workspace. # Get a playbook execution by its ID Source: https://docs.blinkops.com/docs/api/executions/get-a-playbook-execution-by-its-id get /workspace/{ws_id}/executions/{id} API endpoint to retrieve details of a specific playbook execution by its ID. # Get the outputs of an execution by its ID Source: https://docs.blinkops.com/docs/api/executions/get-the-outputs-of-an-execution-by-its-id get /workspace/{ws_id}/executions/{id}/outputs API endpoint to retrieve the outputs of a specific execution by its ID. # Get the trigger event and input params of an execution Source: https://docs.blinkops.com/docs/api/executions/get-the-trigger-event-and-input-params-of-an-execution get /workspace/{ws_id}/executions/{id}/context/inputs Returns the original trigger event payload and the resolved input parameters that were passed when the execution was started. # List playbook executions with filtering Source: https://docs.blinkops.com/docs/api/executions/list-playbook-executions-with-filtering get /workspace/{ws_id}/executions API endpoint to list playbook executions with optional filtering parameters. # List step executions for a specified execution Source: https://docs.blinkops.com/docs/api/executions/list-step-executions-for-a-specified-execution get /workspace/{ws_id}/executions/{id}/steps API endpoint to list all step executions for a specified workflow execution. # Add users to group Source: https://docs.blinkops.com/docs/api/groups/add-users-to-group post /group/{id}/add_users Add one or more users to a group by group ID # Create group Source: https://docs.blinkops.com/docs/api/groups/create-group post /workspace/{ws_id}/table/sys_groups API endpoint to create a new user group in Blink. # Delete group Source: https://docs.blinkops.com/docs/api/groups/delete-group delete /group/{id} API endpoint to delete an existing user group in Blink. # Get groups Source: https://docs.blinkops.com/docs/api/groups/get-groups get /workspace/{ws_id}/table/sys_groups API endpoint to retrieve all user groups in your Blink account. # List group users Source: https://docs.blinkops.com/docs/api/groups/list-group-users get /group/{id} API endpoint to list all users belonging to a specific group in Blink. # Remove users from group Source: https://docs.blinkops.com/docs/api/groups/remove-users-from-group post /group/{id}/remove_users Remove one or more users from a group by group ID # List playbook approvers Source: https://docs.blinkops.com/docs/api/playbook-publish-approval/list-playbook-approvers get /workspace/{ws_id}/get_approvers Returns the list of entities (users/groups) eligible to approve playbook publish requests in the workspace. # List playbook publish approval requests Source: https://docs.blinkops.com/docs/api/playbook-publish-approval/list-playbook-publish-approval-requests get /workspace/{ws_id}/publish_approval_requests Returns a paginated list of playbook publish approval requests visible to the authenticated user. # List all available roles Source: https://docs.blinkops.com/docs/api/roles/list-all-available-roles get /tenant/roles API endpoint to list all available roles that can be assigned to users in Blink. # RQL Source: https://docs.blinkops.com/docs/api/rql Learn how to use Blink's Resource Query Language (RQL) to filter and query resources across your workspace. ## What is RQL? Many of the Blink API endpoints support the use of Resource Query Language (RQL) syntax to select and sort records or filter results. ## RQL Syntax Format An RQL query is a JSON object that can contain the following fields: `offset`, `limit`, `filter` and `sort` (all of them are optional). **INFO** The following RQL syntax examples based on the Blink API for listing records from the Case Management Table. [List Records from Case Management Table](/docs/api/case-management-list-records.api.mdx) ### `offset and limit` These two fields are useful for paging and they are equivalent to `OFFSET` and `LIMIT` in a standard SQL syntax. * `limit` must be greater than 0 and less than or equal to 1000 * `offset` must be greater than or equal to 0 and its default value is 0 #### `offset and limit` example ```json theme={"dark"} { "limit": 30, // returns only the first 30 records (max is 1000). "offset": 0 // the offset from where to return the data. } ``` ### `sort` Sort accepts a list of strings `([]string)` that is equivalent to the SQL `ORDER BY` clause. The default order for a column is ascending order, but you can control the order by using the following prefix: `+` or `-`. `+` means ascending order, and `-` means descending order. #### `sort` example This query is sorting results of the `updated_at` column in a Case Management Table in ascending order as there is a `+` before the `updated_at` field value. ```json theme={"dark"} { "sort": ["+updated_at"] } ``` ### `select` Select accepts a list of strings `([]string)` that is joined with a comma (",") to the RQL `SELECT` clause. #### `select` Example: This query will retrieve only the `id`, `name`, and `status` fields for each record from your case management table. ```json theme={"dark"} { "select": ["id", "name", "status"] } ``` ### `filter` Filter works like the SQL `WHERE` clause. The `$or` operator is used to combine multiple conditions, requiring that at least one of the specified conditions must be true for a record to match. Its type is an array of condition objects. #### `filter` Example: ```json theme={"dark"} { "filter": { "$or": [{ "severity": "high" }, { "severity": "critical" }] } } ``` * If the field follows the format: `field: { : , ...}`, For example: ```json theme={"dark"} { "created_at": { "$gt": "2018-01-01T16:00:00.000Z", "$lt": "2018-06-01T16:00:00.000Z" } } ``` It means that the logical `AND` operator is used between the two predicates. Its type is an object of conditions. ### predicates RQL supports various predicates for filtering: * `$eq`: Equals (can be used on all types) * `$neq`: Not equals (can be used on all types) * `$gt`: Greater than (can be used on numbers, strings, and timestamp) * `$lt`: Less than (can be used on numbers, strings, and timestamp) * `$gte`: Greater than or equal to (can be used on numbers, strings, and timestamp) * `$lte`: Less than or equal to (can be used on numbers, strings, and timestamp) * `$like`: Like (can be used only on type string) ### More Examples: #### Example One A basic query to fetch records from a Case Table with a low status: ```json theme={"dark"} { "limit": 25, "offset": 0, "filter": { "severity": "low" } } ``` #### Example Two A more complex query that filters records from a Case Table based on creation date, severity status, and sorts the results according to the date the case was created in descending order: ```json theme={"dark"} { "limit": 25, "filter": { "case_type": { "$eq": "cloud security" }, "created_at": { "$gt": "2018-01-01T16:00:00.000Z", "$lt": "2018-04-01T16:00:00.000Z" }, "$or": [{ "severity": "high" }, { "status": "open" }] }, "sort": ["-created_at"] } ``` A detailed explanation of the above RQL Query: * `limit`: Limits the number of records returned * `25`: Specifies that the query should return a maximum of 25 records. * `filter`: The main object containing the filtering criteria. * `case_type`: * `$eq`: Filters records where the "case\_type" field is "Cloud Security". * `created_at` * `$gt`: Specifies that the created\_at field must be greater than "2018-01-01T16:00:00.000Z". * `$lt`: Specifies that the created\_at field must be less than "2018-04-01T16:00:00.000Z". * `$or`: Logical OR operator to combine multiple conditions. * `severity`: * `"high"` : Filters records where the severity field is "high". * `status`: * `"open"`: Filters records where the status field is "open". * `sort`: Specifies the sorting order of the returned records. * `["-created_at"]`: Sorts the records in descending order by the created\_at field (the - sign indicates descending order). #### Example Three This query filters the case management records to retrieve those that are open, have a severity status of critical, the case manager is either John Doe or Jane Doe, contain the word "urgent" in the case overview, and were created within the first 4 months of 2024. ```json theme={"dark"} { "filter": { "status": { "$eq": "open" }, "severity": { "$eq": "medium" }, "case_manager": { "$contains_any": ["johndoe@gmail.com", "janedoe@gmail.com"] }, "overview": { "$like": "%urgent%" }, "created_at": { "$gte": "2024-01-01T00:00:00Z", "$lt": "2024-04-31T23:59:59Z" } } } ``` Detailed Explanation of the above RQL Query: * `filter`: The main object containing the filtering criteria * `status`: * `$eq`: Specifies that the status field must be equal to "open". * `priority`: * `$gt`: Specifies that the priority field must be greater than 2. * `case_manager`: * `$contains_any`: Specifies that the "case\_manager" field must contain at least one of the specified values ("[johndoe@gmail.com](mailto:johndoe@gmail.com)" or "[janedoe@gmail.com](mailto:janedoe@gmail.com)"). * `overview`: * `$like`: Specifies that the overview field must match the pattern "%urgent%", meaning it should contain the word "urgent" anywhere within the overview text field. * `created_at`: * `$gte`: Specifies that the "created\_at" field must be greater than or equal to "2024-01-01T00:00:00Z". * `$lt`: Specifies that the created\_at field must be less than "2024-04-31T23:59:59Z". # List Records from Table Source: https://docs.blinkops.com/docs/api/tables/list-records-from-table get /workspace/{ws_id}/table/{table} API endpoint to list records from a Blink table with optional filtering. # Updates Field for Table Source: https://docs.blinkops.com/docs/api/tables/updates-field-for-table put /workspace/{ws_id}/table/{table}/fields/{field} API endpoint to update a field value in a Blink table record. # Get tenant entities (users or groups) Source: https://docs.blinkops.com/docs/api/tenant/get-tenant-entities-users-or-groups get /tenant/entities Returns a paginated list of users and groups in the authenticated user's Blink tenant. # Get groups of user Source: https://docs.blinkops.com/docs/api/users/get-groups-of-user get /user/{id}/groups API endpoint to retrieve all groups that a specific user belongs to in Blink. # Remove a user from groups Source: https://docs.blinkops.com/docs/api/users/remove-a-user-from-groups delete /user/{id}/groups Removes a user from one or more groups. The user cannot be removed from the tenant-wide "All Users" group. # Batch copy of playbooks to target workspace and pack Source: https://docs.blinkops.com/docs/api/workflows/batch-copy-of-playbooks-to-target-workspace-and-pack post /workspace/{ws_id}/batch_copy Batch copy of playbooks to target workspace and pack # Batch move of playbooks to target workspace and pack Source: https://docs.blinkops.com/docs/api/workflows/batch-move-of-playbooks-to-target-workspace-and-pack post /workspace/{ws_id}/batch_move Batch move of playbooks to target workspace and pack, the order of the # Create a new playbook Source: https://docs.blinkops.com/docs/api/workflows/create-a-new-playbook post /workspace/{ws_id}/playbooks Creates a new playbook in the specified workspace and immediately publishes it. # Delete a playbook by its ID Source: https://docs.blinkops.com/docs/api/workflows/delete-a-playbook-by-its-id delete /workspace/{ws_id}/playbooks/{id} API endpoint to delete a playbook by its unique identifier in Blink. # Edit playbook metadata Source: https://docs.blinkops.com/docs/api/workflows/edit-playbook-metadata put /workspace/{ws_id}/playbooks/{id}/edit Updates the name, description, tags, and runner of the playbook with the given ID. Updating the runner requires the ViewAction permission on RunnerObject. # Execute a playbook Source: https://docs.blinkops.com/docs/api/workflows/execute-a-playbook post /workspace/{ws_id}/playbooks/{id}/execute API endpoint to trigger the execution of a playbook in Blink. # Get a playbook by its ID Source: https://docs.blinkops.com/docs/api/workflows/get-a-playbook-by-its-id get /workspace/{ws_id}/playbooks/{id} API endpoint to retrieve a playbook's details by its unique identifier. # Get a playbook version by branch and version number Source: https://docs.blinkops.com/docs/api/workflows/get-a-playbook-version-by-branch-and-version-number get /workspace/{ws_id}/playbooks/{id}/version/{branch}/{version} API endpoint to retrieve a specific playbook version by branch and version number. # Get connections used by a list of playbooks Source: https://docs.blinkops.com/docs/api/workflows/get-connections-used-by-a-list-of-playbooks post /workspace/{ws_id}/playbooks/get-playbooks-used-connections Returns the list of connections (with vendor info) that are referenced by the given playbook IDs. # Get the latest draft playbook version for a playbook Source: https://docs.blinkops.com/docs/api/workflows/get-the-latest-draft-playbook-version-for-a-playbook get /workspace/{ws_id}/playbooks/{id}/draft API endpoint to retrieve the latest draft version of a playbook in Blink. # Get the latest public playbook version for a playbook Source: https://docs.blinkops.com/docs/api/workflows/get-the-latest-public-playbook-version-for-a-playbook get /workspace/{ws_id}/playbooks/{id}/public API endpoint to retrieve the latest published version of a playbook in Blink. # List all versions metadata of a playbook Source: https://docs.blinkops.com/docs/api/workflows/list-all-versions-metadata-of-a-playbook get /workspace/{ws_id}/playbooks/{id}/versions API endpoint to list metadata for all versions of a specific playbook. # List playbooks with optional filtering Source: https://docs.blinkops.com/docs/api/workflows/list-playbooks-with-optional-filtering get /workspace/{ws_id}/playbooks API endpoint to list all playbooks in your workspace with optional filtering. # Share portal app Source: https://docs.blinkops.com/docs/api/workflows/share-portal-app post /playbooks/{id}/portal_share Share portal app with other users or groups # Un-share portal app Source: https://docs.blinkops.com/docs/api/workflows/un-share-portal-app post /playbooks/{id}/portal_unshare Un-share portal app with other users or groups # Add entities to workspace Source: https://docs.blinkops.com/docs/api/workspaces/add-entities-to-workspace post /workspaces/{ws_id}/entities API endpoint to add entities such as users or groups to a Blink workspace. # Assign a role to a user or group in a workspace Source: https://docs.blinkops.com/docs/api/workspaces/assign-a-role-to-a-user-or-group-in-a-workspace post /workspaces/{ws_id}/{entity_type}/{entity_id}/role/{role} API endpoint to assign a role to a user or group within a Blink workspace. # Get workspace details Source: https://docs.blinkops.com/docs/api/workspaces/get-workspace-details get /workspaces/{ws_id} API endpoint to retrieve details about a specific Blink workspace. # Update the Workspace Settings Source: https://docs.blinkops.com/docs/api/workspaces/update-the-workspace-settings put /workspaces/{ws_id}/settings Update the workspace settings by provided values # Account Management Source: https://docs.blinkops.com/docs/blink-platform/account-management/account-management This page provides an overview of the features and functionality available in your Blink Ops account settings, as well as Blink's security and legal policies. ## Profile Details Access and manage your **Username**, **Email Address**, change your **Password**, and enable **Two-Factor Authentication** here. **Note:** If you log in using Google, GitHub, Microsoft, or SSO, the options to change your password or enable two-factor authentication will not be available. *** ## API Keys In the API Keys settings page you can manage your personal API keys of the Blink platform. You can create, delete and edit your API keys. *** ## Accounts - Users and Service Accounts A Tenant-Admin can create a service account or invite a user to an account and then immediately add the user to groups and workspaces, and define a user role. See [Blink Users](/docs/blink-platform/account-management/accounts) for more details. *** ## Groups **Groups** allow you to manage users by teams or departments. You can assign specific roles to groups within workspaces, granting all members access. See [Blink Groups](/docs/blink-platform/account-management/groups) for more information. *** ## Roles Each Blink Ops user can be assigned one of three roles: **Admin**, **Builder**, or **Consumer**. Learn more in [Blink User Roles](/docs/blink-platform/account-management/roles). *** ## Workspace Management The **Workspace Management** section allows you to view and manage all your workspaces. See [Workspace Management](/docs/blink-platform/account-management/workspace-management) for more details. *** ## General In the **General** tab of account settings, you can apply various configurations to your Blink Ops account. See [General Settings](/docs/blink-platform/account-management/general) for details. *** ## AI Settings See [AI Settings](/docs/blink-platform/account-management/ai-settings) for details. 1. **Enable Builder Copilot test data access** – When enabled, the [Builder Copilot](/docs/builder-copilot/builder-copilot) can access workflow testing execution data from the current session to generate more context-aware and precise configuration suggestions. If a step produces an error in its output, you can ask Builder Copilot to fix it, with the error message included in its context for more accurate and effective resolutions. When disabled, suggestions are based only on the workflow definition and user input. 2. AI Models- Enable Blink to use AI models from your own AWS account (via Amazon Bedrock) instead of Blink's shared AI infrastructure. When active, all AI calls are routed through your account. *** ## Audit Logs **Audit Logs** track and monitor activities across three main categories within your tenant. See [Audit Logs](/docs/blink-platform/account-management/audit-logs) for more information. *** ## Account Security Settings Learn how to configure your account's security settings. For detailed instructions, visit [Account Security Settings](/docs/blink-platform/account-management/identity-providers/identity-providers). ## Resetting Your Password Instructions about how to reset your password for your Blink Account. See [Resetting your Password](/docs/blink-platform/account-management/resetting-your-password) for more details. ## Security, Legal, and Privacy Policy Access Blink Ops’ security statement and privacy policy here. See [Security and Legal](/docs/blink-platform/account-management/security-and-legal/security-statement) for further information. # About Accounts Source: https://docs.blinkops.com/docs/blink-platform/account-management/accounts How to manage your Blink account settings, including profile, preferences, and organization details. Each company using Blink has its own separate account, fully isolated from all other companies. Within an account, groups can be created to organize users, such as teams or departments. The Blink platform supports two types of accounts: [user account](#users) and [service accounts](#service-account), each serving different purposes. ## User Account Vs Service Account A [user account](#users) is an identity created for an individual to access and interact with systems, applications, and services, typically requiring authentication via a username and password, and often equipped with permissions aligned with the individual's role. On the other hand, a [service account](#service-account) is designed for use by applications, services, or automated processes rather than human users. Service accounts are authenticated using credentials such as keys or tokens and are granted specific permissions to perform predefined tasks, allowing for secure and automated access to resources without human intervention. While user accounts are managed based on the individual's lifecycle, service accounts are managed according to the application's needs. ## Users Each company using Blink operates within its own separate account, fully isolated from all other accounts. Only Admin users have the authority to invite new users and manage user access, including adding or removing users from groups. Before a user can access the Blink platform, they must be added to the account. Admins can invite a user, assign them to specific groups and workspaces, and define their role in advance. Once the invited user accepts the invitation, all their workspaces, group memberships, and roles are already configured, allowing them to start using the platform immediately without additional setup. **Please note**: Deleting a user does not remove any associated resources, such as workspaces, workflows, or connections. ### Inviting a New User Click on "Account" option. You will be navigated to the Accounts Page in your **Account Settings**. In the **Users** tab of the 'Accounts' page, click the "Invite User" button in the top-right corner. Provide the email address of the new user you would like to invite The user will receive an email invite and once accepted, appear in the member list of the account. There are three types of built-in [Tenant Roles](/docs/blink-platform/account-management/roles#tenant-role-scope) to assign the invited user: * [Admin](/docs/blink-platform/account-management/roles#admin): As an Admin, you have full access to all workspaces as well as control over all settings across the Blink Platform. * [Consumer](/docs/blink-platform/account-management/roles#consumer): As a Consumer, you have full access to the self-service portal as well as read and write permissions in the user's Workspaces. * [Builder](/docs/blink-platform/account-management/roles#builder): As a Builder, you have complete access to read, write, and execute permissions within the user's Workspaces. * [Tenant Guest](/docs/blink-platform/account-management/roles#4-tenant-guest) As a Tenant Guest, you only have access to view a workspace. You can also assign a user a custom role within the tenant scope. ### Checking the Status of a Member of your Account A member can have one of the following statuses:
| User status | Description | Admin actions available | | ----------- | -------------------------------- | ----------------------------------------------------------------------- | | Active | The user has signed up to Blink. | Deactivate user, remove user or check which groups the user belongs to. | | Inactive | The user is blocked from Blink. | Re-activate. | | Invited | The user is invited to Blink. | Re-send or cancel the invite. |
The following images shows Admin actions for an inactive user. The following screenshot shows Admin actions for an invited user. The following screenshot shows Admin actions for an active user. ## Service Account A service account is a specialized, non-human account used by locations, services, or automated processes to access resources and perform tasks. It is authenticated through credentials such as API keys or tokens and is granted specific permissions tailored to its intended functions, enabling secure and automated operations without human intervention. **Note**: Only [Tenant Admin](/docs/blink-platform/account-management/roles#admin) users can create a service account and designate roles. ### How to create a New Service Account Click on "Account" option. You will be navigated to the Accounts Page in your **Account Settings**. Navigate to the "Service Account" Tab. In the "Service Account" tab of the Accounts page, click the "Create new account" button in the top-right corner. Provide a Name for your Service Account, optionally add a description and choose a role: * [Admin](/docs/blink-platform/account-management/roles#admin): As an Admin, the account has full access to all workspaces as well as control over all settings across the Blink Platform. * [Builder](/docs/blink-platform/account-management/roles#builder): As a Builder, the account has complete access to read, write, and execute permissions within the user's Workspaces. If the service account is assigned [Tenant- Builder Role](/docs/blink-platform/account-management/roles#builder), the [Tenant- Admin](/docs/blink-platform/account-management/roles#admin) will have to invite the Service Account to each Workspace they want it to operate in. * [Consumer](/docs/blink-platform/account-management/roles#consumer): As a Consumer, the account has full access to the self-service portal as well as read and write permissions in the user's Workspaces. ### Editing a Service Account Click on the Service Account's table field you would like to make changes to. The changes will be applied automatically. ### Deleting a Service Account

Click on the icon in the last column and click on the delete option and confirm you want to delete the selected service account by clicking the "Delete" button.

### Service Account Information Each service account is created with one API Key. Access the Service Account's API Key by 1.

Clicking on the icon in the last column and click on the "Account info" option and to view your service account's information and API key.

OR 2.

Clicking the icon to copy your API Key.

# AI Settings Source: https://docs.blinkops.com/docs/blink-platform/account-management/ai-settings ## AI Features **Enable Builder Copilot test data access**- When enabled, the Builder Copilot can access workflow testing execution data from the current session to generate more context-aware and precise configuration suggestions. When disabled, suggestions are based only on the workflow definition and user input. *** ## AI Models Blink supports three options for AI infrastructure: * **Blink** *(recommended)* – Uses Blink-managed AI infrastructure through Blink's Amazon Bedrock account. This is the default option and provides a fully managed experience, with all AI requests routed through Blink. * **[Amazon Bedrock](/docs/blink-platform/account-management/ai-settings#amazon-bedrock-prerequisites)** – Uses your own Amazon Bedrock account. When selected, all AI-related requests are executed through your AWS infrastructure, giving you full control over your AI resources and billing. * **[Azure AI Foundry](/docs/blink-platform/account-management/ai-settings#microsoft-azure-foundry-prerequisites)**- Enables Blink to use AI models from your own Azure subscription (via Azure AI Foundry) instead of Blink's shared AI infrastructure. When active, all AI calls are routed through your account. *** ## How to Configure the Chosen AI Model ### Amazon Bedrock Prerequisites * An AWS account with permission to deploy CloudFormation stacks and create IAM roles. When you select Amazon Bedrock as your AI Model, all platform-wide AI operations are routed directly through your organization’s Microsoft Foundry account. This includes [Agents](/docs/agent-builder/agent-builder), [Agent Blink](/docs/case-management/agent-blink), [Builder Copilot](/docs/builder-copilot/builder-copilot), and other AI-powered capabilities across the Blink platform. ### Limitations **Important to Note**: [Knowledge sources](/docs/agent-builder/building-the-agent), in the Agent Builder, are not currently supported when using [Amazon Bedrock as the AI provider](/docs/blink-platform/account-management/ai-settings#configuration-amazon-bedrock-as-the-ai-provider). Knowledge functionality is available only when using [Blink as the AI provider](/docs/blink-platform/account-management/ai-settings#ai-models) *** ### Setup Steps Navigate to **Account Settings → AI Settings → AI Models**. In the **AI Provider** dropdown, select **Amazon Bedrock**. Blink automatically generates a unique **External ID** for your account and displays it on screen. **What is the External ID?** It is a secret token that Blink embeds in every `AssumeRole` request. Your IAM trust policy must require it, which prevents any other AWS account from assuming your role even if they know your Role ARN. Do not share it. Fill in: * **AWS Account ID** — the 12-digit numeric ID of the AWS account where Blink should operate (e.g. `123456789012`). * **IAM Role Name** — the name you want to give the IAM role that Blink will assume. The default suggestion is `BlinkBedrockExecutionRole`; you can use any name that fits your naming conventions. Click **Open in AWS Console**. This opens the AWS CloudFormation quick-create page with all parameters pre-filled: | Parameter | Value | | ----------- | ------------------------------ | | Stack name | `blink-bedrock-access` | | External ID | your External ID from step 3 | | Role Name | the name you entered in step 4 | In the AWS Console, scroll to the bottom, acknowledge the IAM capability checkbox, and click **Create stack**. Wait for the stack status to reach `CREATE_COMPLETE` (usually under 2 minutes). **What does the stack create?** A single IAM role in your account. The role's trust policy allows Blink's AWS account to assume it — but only when the correct External ID is presented. The role's permission policy grants the following actions, scoped to Anthropic foundation models and cross-region inference profiles only: * `bedrock:InvokeModel` * `bedrock:InvokeModelWithResponseStream` * `bedrock:Converse` * `bedrock:ConverseStream` * `bedrock:CountTokens` Return to the Blink AI Settings page and click **Test connection**. Blink will attempt to assume the role and invoke a lightweight Bedrock call using the values currently in the form - **no need to save first**. A success confirmation means the role and permissions are correctly configured. Click **Save changes** to activate the integration. **Reverting to Blink's Default Provider**: Switch the **AI Provider** dropdown back to **Blink** and save. The IAM role in your AWS account is not deleted automatically — you can clean it up by deleting the `blink-bedrock-access` CloudFormation stack. **Reverting to Blink's Default Provider** Switch the **AI Provider** dropdown back to **Blink** and save. The app registration and federated credential in your Azure tenant are not removed automatically — you can delete them via the Azure Portal if no longer needed. *** ### Required Bedrock Model Access The customer must enable access to the following cross-region inference profiles in their AWS account before the integration will work. All are from the **Anthropic** provider in Bedrock. **How to enable:** AWS Console → Amazon Bedrock → Model access → Manage model access → select each model below → Request model access. **Note**: All models in the table must be enabled | Model | Bedrock Model ID | | ----------------- | ------------------------------------------------- | | Claude Sonnet 4.6 | `global.anthropic.claude-sonnet-4-6` | | Claude Haiku 4.5 | `global.anthropic.claude-haiku-4-5-20251001-v1:0` | **How to Confirm a Model is Ready**: Go to **AWS Console → Amazon Bedrock → Playgrounds → Chat**, select the model, and send a test message. A successful response confirms the model is accessible. ### Microsoft Foundry Prerequisites * An Azure account with an Azure AI Foundry resource created. * The following Claude models deployed in your Foundry resource, using these **exact deployment names**: * `claude-sonnet-4-6` * `claude-haiku-4-5` * Permission to create app registrations and run scripts in your Azure subscription (Owner or Contributor + Application Administrator). * Access to Blink's **AI Settings** page (Account Settings → AI Models). When you select Azure AI Foundry as your AI Model, all platform-wide AI operations are routed directly through your organization’s Microsoft Foundry account. This includes [Agents](/docs/agent-builder/agent-builder), [Agent Blink](/docs/case-management/agent-blink), [Builder Copilot](/docs/builder-copilot/builder-copilot), and other AI-powered capabilities across the Blink platform. ### Limitations **Important to Note**: [Knowledge sources](/docs/agent-builder/building-the-agent), in the Agent Builder, are not currently supported when using [Microsoft Foundry as the AI provider](/docs/blink-platform/account-management/ai-settings#microsoft-azure-foundry-prerequisites). Knowledge functionality is available only when using [Blink as the AI provider](/docs/blink-platform/account-management/ai-settings#ai-models) *** ### Setup Steps Navigate to **Account Settings → AI Models**. In the **AI Provider** dropdown, select **Azure AI Foundry**. Fill in: * **Subscription ID** — the ID of the Azure subscription that contains your Foundry resource. Find it in Azure Portal → *Subscriptions*. * **Resource Group** — the resource group that contains your Azure AI Foundry resource. * **Resource Name** — the name of your Azure AI Foundry resource (e.g. `my-foundry`). Click **Generate Setup Script**. Blink generates a Bash script pre-filled with the values you entered. Open Azure Cloud Shell (Bash), paste the script, and run it. The script uses the following parameters: | **Parameter** | **Value** | | --------------------- | -------------------------------------- | | Subscription ID | your Subscription ID from step 3 | | Resource Group | your Resource Group from step 3 | | Resource Name | your Foundry Resource Name from step 3 | | OIDC Issuer / Subject | provided by Blink automatically | **What does the script do?**  It creates an Azure AD app registration and service principal in your tenant, then configures a federated identity credential that authorises Blink's cluster identity to obtain access tokens — no client secrets or API keys are stored anywhere. It also assigns the *Cognitive Services User* role on your Foundry resource to that app registration. The script is safe to re-run. If the app registration already exists it updates the federated credential in place. When the script completes, it outputs two values you will need in the next step: * **Entra Tenant ID** * **Application (Client) ID** Paste both values from the script output into the corresponding fields in Blink. Click **Test connection**. Blink will authenticate with your Azure tenant and invoke each required Claude model deployment — **no need to save first**. A success confirmation means the federated credential and model deployments are correctly configured. Click **Save changes** to activate the integration. **Reverting to Blink's Default Provider** Switch the **AI Provider** dropdown back to **Blink** and save. The app registration and federated credential in your Azure tenant are not removed automatically — you can delete them via the Azure Portal if no longer needed. *** ### Required Microsoft Foundry Model Access You must deploy the following Claude models in your Azure AI Foundry resource before the integration will work. The deployment names must match exactly — Blink uses these names when invoking the models. * **How to deploy**: Azure Portal → Azure AI Foundry → your resource → models + endpoints → Deploy model → select the model → set the deployment name exactly as shown above. * **How to confirm a model is ready:** Go to Azure AI Foundry → Playgrounds → Chat, select the deployment, and send a test message. A successful response confirms the model is accessible. Both models must be deployed before testing the connection. The connection test will fail if either deployment is missing or named differently. | **Model** | **Required Deployment Name** | | ----------------- | ---------------------------- | | Claude Sonnet 4.6 | `claude-sonnet-4-6` | | Claude Haiku 4.5 | `claude-haiku-4-5` | *** # API Keys Source: https://docs.blinkops.com/docs/blink-platform/account-management/api-keys Create and manage API keys for programmatic access to the Blink platform. In the API Keys settings page you can manage your personal API keys of the Blink platform. You can create, delete and edit your API keys. **NOTE**: There always has to be one API key available. The maximum number of API keys at any given time is `5`. ## Create API Key Select the **New API Key** button in the top-right corner Give your API key a name, description (optional) and choose when the API Key expires (after 30 days, 90 days or never ). Then click the create button in the bottom-right corner. It will be added to the table. | Parameter | Description | | ----------- | -------------------------------------------------------------------------------------------------------- | | Name | Name given to the API Key | | Description | Description given to the API Key | | Key | The API key itself | | Created At | The time you created the API key | | Expires | It will display: the day of expiration, never- if no expiry is set or expired- if expiration date passed | | Last used | The last time you used the API key | ## Generate a New API Key **Note**: This setting can only be used with the default API key which is now a legacy feature so will only appear in certain Tenants To generate a new API key, click the icon on the right-hand side of the default API key row, then select **Rotate**. A popup will appear asking you to confirm if you are sure you would like to rotate the API key. Select the confirm button *** ## Edit API Key If you want to make any changes to the API information, double click on the cell and make the desired changes. You can change the API key name or description. *** ## Delete API Key If you want to delete an API Key, click on the icon on the right-hand side of the row and select the **delete** option. *** ## Using your Personal API Key in Workflows Click anywhere on the workflow within the Workflow pack. You will be redirected to the Workflow Editor. Click the icon in the top right-hand side corner. Choose the Settings option to access the Workflow settings. Go to the **Run Methods** section and select the **REST API** or **CLI** method. Under the command text field, select which **personal API key** from the dynamic dropdown menu. Upon selection, your **personal API key** will be added to the command, allowing you to proceed using the chosen run method for your chosen Workflow. # Audit Logs Source: https://docs.blinkops.com/docs/blink-platform/account-management/audit-logs The Audit Log monitors user activity in the tenant The **Audit Log** provides a comprehensive, timestamped record of all key activities occurring within the tenant. It is a critical tool for monitoring changes, troubleshooting issues, and ensuring compliance by giving administrators visibility into who did what and when. **Note**: Audit logs are retained for a duration of 30 days. Audit log events are categorized into the following areas: * Approval management * Cases * Case related tables * Connections * Dashboards * Global variables * Runners * Self-service apps * Tables * Tenant admin settings * Tenant user management * Users * Workflows * Workspace management For a complete list of Audit Log events, see this [section](#categories-and-events). The audit logs do not track changes to data or content, such as workflow action updates, workflow executions, modifications to table records, or changes to cases. *** ## Audit Log Table Content Each log entry includes the following information: * **Category** – The general type of activity: Setting updates, System configuration, or User actions. * **Action** – The specific action that occurred. * **Parameters** – Key data relevant to the action, such as the affected username, Workflow name, or API endpoint. * **Details** – Additional context or information about the action. * **Workspace** – The name of the workspace where the action took place. * **Done by** – The email address of the user who initiated the action. * **Date and Time** – When the action was performed. *** ## Categories and Events In the following section, you can find a complete overview of Blink’s audit log categories and the types of events captured within each. Audit logs in Blink are designed to give you full visibility into user activity, system changes, and workflow executions across the platform. ### Approval Management
| **Event** | **Description** | | ----------------- | ------------------------------------------------------- | | Request approved | A submitted request was approved by an authorized user. | | Request denied | A submitted request was denied by an authorized user. | | Request submitted | A request was submitted for approval. |
*** ### Cases
| **Event** | **Description** | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- | | Case exported | A case was exported to a downloadable format. | | Case shared | A case was shared with external parties or users. | | Case viewed | Logged when a user opens and views the details of a case. | | Case closed | Logged when a case has been closed | | Case response action triggered | Logged when a predefined response action (e.g., notification, remediation step, or ability workflow) is executed for a case. | | Case escalated | Logged when a the [escalated action](/docs/case-management/cases/case-overview/case-overview#escalate-case) in the Case Overview is used. | | Table exported to CSV | A case table was exported in CSV format. |
*** ### Case Related Tables Case related tables refer to **all** tables in [Case Management](/docs/case-management/case-management) including: the [Cases Table](/docs/case-management/cases/cases), [Alerts Table](/docs/case-management/alerts/alerts), [Observable Table](/docs/case-management/observables/observables), [Attachments Table](/docs/case-management/attachments/attachments),[Tasks Table](/docs/case-management/tasks/tasks) or your own [Custom Table](/docs/case-management/case-management-settings#create-a-custom-table) created in [Case Management](/docs/case-management/case-management)
| **Event** | **Description** | | | --------------------------- | ------------------------------------------------------------ | - | | Custom cases table created | A case management tables was created. | | | Custom cases table edited | An existing case management table was edited. | | | Case related tables read | Logged when a case management tables was accessed or viewed. | | | Case related tables deleted | A case management tables was deleted. | | | Exported to CSV | Data from a custom cases table was exported as a CSV file. | | | Field created | A new field was added to a case management table. | | | Field edited | A field in a case management tables was updated. | | | Field deleted | A field was removed from a case management tables | |
*** ### Connections
| **Event** | **Description** | | ------------------ | -------------------------------------------------- | | Connection created | A new integration connection was created. | | Connection deleted | An existing integration connection was removed. | | Connection edited | An integration connection was modified or updated. |
*** ### Dashboards
| **Event** | **Description** | | ------------------------- | --------------------------------------------------------------- | | Dashboard activated | A dashboard was activated and made live. | | Dashboard created | A new dashboard was created. | | Dashboard deactivated | A dashboard was deactivated. | | Dashboard deleted | A dashboard was deleted. | | Dashboard edited | Changes were made to a dashboard’s configuration or layout. | | Dashboard metadata edited | Metadata for the dashboard (e.g., tags, ownership) was updated. |
*** ### Global Variables
| **Event** | **Description** | | ----------------------- | --------------------------------------------------- | | Global variable created | A new global variable was created. | | Global variable deleted | A global variable was removed from the system. | | Global variable edited | An existing global variable was updated or changed. |
*** ### Runners
| **Event** | **Description** | | --------------------------- | -------------------------------------------------------------------- | | Runner group created | A new group for managing runners was created. | | Runner group deleted | A runner group was deleted. | | Runner group edited | A runner group’s settings or members were updated. | | Runner group set as default | A runner group was marked as the default for new workflows or tasks. |
*** ### Self-Service Apps
| **Event** | **Description** | | ------------- | ---------------------------------------------------- | | App created | A new self-service app was created. | | App deleted | A self-service app was removed. | | App published | A self-service app was published and made available. |
*** ### Tables
| **Event** | **Description** | | --------------------- | ----------------------------------------------- | | Field created | A new field was added to a data table. | | Field deleted | A field was removed from a data table. | | Field edited | A field in a table was modified. | | Table created | A new data table was created. | | Table read | A new data table was accessed or viewed | | Table deleted | A data table was deleted. | | Table edited | A data table was updated or modified. | | Table exported to CSV | A table’s contents were exported to a CSV file. |
*** ### Tenant Admin Settings
| **Event** | **Description** | | | ---------------------------------- | ------------------------------------------------------------------- | - | | Audit logs exported | Audit logs were exported for review or archiving. | | | Blink-cloud runner updated | Settings for the Blink cloud runner were updated. | | | Default tenant runner updated | The default runner for the tenant was changed. | | | Runner auto upgrade updated | Auto-upgrade settings for runners were modified. | | | SAML role mapping updated | Role mapping configuration for SAML was updated. | | | SAML settings updated | SAML authentication settings were changed. | | | Two-factor authentication disabled | Two-factor authentication was disabled for the tenant. | | | Two-factor authentication enabled | Two-factor authentication was enabled for the tenant. | | | Time format updated | The time display format used across the Blink platform was changed. | | | Date format updated | The date display format used across the Blink platform was changed. | |
*** ### Tenant User Management
| **Event** | **Description** | | ---------------------------------------- | -------------------------------------- | | Group created | A new group was created. | | Group deleted | An existing group was deleted. | | Group name updated | The name of a group was changed. | | Role created | A new role was created. | | Role deleted | An existing role was deleted. | | Role updated | An existing role was updated. | | Service account activated | A service account was activated. | | Service account created | A new service account was created. | | Service account deactivated | A service account was deactivated. | | Service account deleted | A service account was deleted. | | Service account group assignment updated | A service account's group was updated. | | Service account role changed | A service account's role was changed. | | User activated | A user was activated. | | User deactivated | A user was deactivated. | | User deleted | A user was deleted. | | User group assignment updated | A user's group assignment was updated. | | User invited | A user was invited. | | User role changed | A user's role was changed. |
*** ### Users
| **Event** | **Description** | | --------------- | ----------------------- | | User logged in | A user logged in. | | User logged out | A user logged out. | | API key created | An API key was created. | | API key deleted | An API key was deleted. |
*** ### Workflows
| **Event** | **Description** | | ------------------------- | ------------------------------- | | Pack created | A new pack was created. | | Pack deleted | A pack was deleted. | | Pack edited | A pack was edited. | | Workflow activated | A workflow was activated. | | Workflow created | A new workflow was created. | | Workflow deactivated | A workflow was deactivated. | | Workflow deleted | A workflow was deleted. | | Workflow published | A workflow was published. | | Workflow settings updated | Workflow settings were updated. |
*** ### Workspace Management
| **Event** | **Description** | | ---------------------- | ------------------------------------------- | | Workspace created | A new workspace was created. | | Workspace deleted | A workspace was deleted. | | Workspace name updated | A workspace’s name was updated. | | User invited/added | A user was invited or added. | | User removed | A user was removed. | | User role changed | A user’s role in the workspace was changed. |
*** ## External Audit Log Integration Blink supports native audit log streaming to external SIEM systems, allowing organizations to integrate Blink audit data into tools like Splunk or Elasticsearch. This feature gives security teams greater visibility and control by centralizing audit logs for compliance, monitoring, and incident response without the need for manual exports. [Tenant admins](/blink-platform/account-management/roles#1-admin) can configure their SIEM endpoint directly in Blink, test the connection, and begin streaming audit logs in real time. ***

In the top right-corner of the Audit Log page, select the icon

1. **Enable audit log streaming**: * When enabled, audit logs will be delivered to your specified external destination in real time. * Disabling this will stop all log delivery and deactivate the form below. 2. **URL**: * The destination URL for your external logging service. This must be a reachable HTTPS endpoint that supports log ingestion. 3. **Authentication Token**: * A token or API Key used to authenticate requests to your external logging endpoint. This is required for secure delivery of audit logs. 4. **Destination Type**- Select the type of destination where logs will be sent: * [Splunk HEC](#generating-a-splunk-http-event-collector-hec-token) * HTTP (Bearer Auth) * Elasticsearch You can verify that Blink is successfully connected to your selected SIEM platform by clicking the 'Test Connection' button.
*** ## Configuration Guide: Generating a Splunk HTTP Event Collector (HEC) Token Follow this step-by-step guide, to learn how to generate Splunk HTTP Event Collector (HEC) token, which is required for integrating Splunk with the Blink platform. This token is required to integrate Splunk with the Blink platform in order to stream Blink's audit logs to a selected external destination. **Note**: The images used in this guide are for illustration purposes only. Your Splunk configuration may differ based on your organization's environment, existing settings, and indexing policies. Use the images as a visual reference to help guide you through each step. Log in to your [Splunk Enterprise account](https://login.splunk.com). In the top-right corner, click on **Settings**, then search for **HTTP Event Collector** and select it. Fill in all required fields for the data source configuration. Choose the appropriate indexes that the 'HTTP Event Collector' token will be allowed to access. **Reminder**: The indexes displayed in the example image may differ from your organization’s configuration. Be sure to select the correct indexes based on your environment and data routing needs. Review all the details you have entered to ensure everything is accurate before proceeding. Once the token has been generated in Splunk, copy it and securely store it. To complete the integration with Blink, go to the [Audit Settings](#external-audit-log-integration) section of the Blink platform and do the following: * Paste the token into the **Authentication Token** field * Enter the **URL**: If the HEC feature is enabled in the Splunk Enterprise platform you will see the port it uses (by default, it's `8088`). Your full url will look something like this `https://splunk.yourcompany.com:8088` * Select **Splunk HEC** as the **Destination Type** This ensures that Blink can successfully forward audit logs to your Splunk instance. Click **Test Connection** to verify that the URL and token have been entered correctly and that Blink can successfully communicate with your Splunk instance. Once the connection is validated, click **Save Settings** to apply the configuration. # Enabling Two Factor Authentication Source: https://docs.blinkops.com/docs/blink-platform/account-management/authentication Configure authentication methods for your Blink account, including SSO and multi-factor authentication. When signing up for Blink, you have the option to enable two-factor authentication (2FA) for enhanced account security. Two-factor authentication adds an extra layer of protection by requiring users to verify their identity using two separate forms of identification before accessing their account. **Note**: Two-Factor Authentication is only available for the **email login** option. ## Enabling Two-Factor Authentication (2FA) for Your Account Two-Factor Authentication (2FA) is enabled at the tenant level and is automatically enforced for all users in the tenant upon login. Navigate to the bottom-left corner of the Blink interface and click on the circle displaying your initials. From the 'User Settings' menu, select 'General'. On the 'General Settings' page, locate the 'Enable Two-Factor Authentication' option and toggle it on to activate the feature. Click 'Save Settings' to confirm the activation of Two-Factor Authentication. Using your preferred authenticator app, scan the barcode displayed on the screen. In your authenticator app, retrieve the unique 6-digit code. Enter this code in the designated field, then click 'Continue'. You will be redirected to the Sign-In page. Sign back into your Blink account. Follow the prompt to enter a new authentication code from the same authenticator app to complete the verification. After successfully logging in, Two-Factor Authentication will be fully activated for your Blink account. At any time, you can choose to disable Two-Factor Authentication by toggling the 'Enable Two-Factor Authentication' switch off. # General Settings Source: https://docs.blinkops.com/docs/blink-platform/account-management/general Configure general account settings including organization name, timezone, and preferences in Blink. ## General In **General Settings** you can choose to: * Customize your account by adding your own logo. Simply select the image box, and upload your preferred logo either from **uploading a file** or by entering the **image URL** in the **URL tab**. Your logo will be displayed in the bottom-left corner of your screen. **Note** The logo will be displayed in a squared ratio of 30px. We recommend uploading a picture with a size of at least 30x30 px. The File format must be either a **JPG** or a **PNG**. The File size can be up to **10 MB**. *** ## Main Settings * Enable or Disable **runners to auto upgrade** by clicking the toggle button. * Enable or Disable **Blink-Cloud runners** by clicking the toggle button. * Enable or Disable [two factor authentication](/docs/blink-platform/account-management/authentication) by clicking the toggle button Two-Factor Authentication (2FA) is enabled at the tenant level and is automatically enforced for all users in the tenant upon login. * Select a **Default Tenant Runner** from the drop down menu. * **Date Format** – Select the preferred date format to be applied across the entire Blink platform: * **MM/DD/YYYY** * **DD/MM/YYYY** * **Time Format** – Select the preferred time display format for the Blink platform: * **12-hour (AM/PM)** * **24-hour** * [Blink Portal Custom Header](/docs/blink-platform/blink-portal/blink-portal#customize-the-blink-portal-logo-and-header)- Set the header text that will be displayed in the [Blink Portal](/docs/blink-platform/blink-portal/blink-portal) *** ## Managed security service provider (MSSP) * Appoint a provider to manage the account by entering the designated provider code. For more information visit the [Service Provider](/docs/blink-platform/service-providers/service-providers.mdx) section of our documentation. *** ## Approvals The [publish approval process](/docs/workflows/managing-workflows/publish-approval/publish-approval) ensures that workflow changes are reviewed before being published, creating a streamlined approval process. These settings enable administrators to maintain stricter control over publishing permissions. * **Restrict approvals to selected reviewers:** when this setting is enabled, only the selected reviewers will be able to review and approve the workflow changes. * **Restrict reviewers to the same group:** when this setting is enabled, the builder who submitted the changes for approval can only choose reviewers who belong to the same group as the builder. *** ## Bots * [Bot for Slack](/docs/blink-platform/blink-portal/blink-bot-for-slack): Create a Slack connection. See [creating a new connection](/docs/workflows/building-workflows/connections/creating-connection) for more details. * [Bot For Zoom](/docs/blink-platform/blink-portal/zoom-slackbot): Create a Zoom connection. See [creating a new connection](/docs/workflows/building-workflows/connections/creating-connection) for more details. # Blink Groups Source: https://docs.blinkops.com/docs/blink-platform/account-management/groups Groups are used to manage groups of users, for example work teams and departments Groups are used to manage groups of users, for example work teams and departments. You can attach a specific role to a group inside a workspace, thus granting access to all group members. ## Creating a new group 1. Navigate to **Account Settings** and select the icon. 2. Click **New Group**. In the dialog box, fill in the group name and description. 3. Then click **Save**. ## Adding a member to a group ### Adding a member from the Users tab 1. Navigate to **Account Settings** and select the icon. 2. Select a user and double click on the **Groups** column. 3. From the dropdown menu, select a group you wish to add the user to. 4. Click **Add**. ### Adding a member from the Groups tab 1. Navigate to **Account Settings** and select the icon. 2. Select a **Group** and double click on the **Users** column. 3. From the dropdown menu, select a user you wish to add to the group. 4. Click **Add**. ## Adding groups to a workspace 1. Click to navigate to the **Workspaces Settings**. 2. In the empty text field invite a new member to your workspace by **User, Group or Email** 3. Click **Add**. The group is added to the workspace. # Configuring a SAML application on Azure AD Source: https://docs.blinkops.com/docs/blink-platform/account-management/identity-providers/azure Instructions on how to configure a SAML SSO application with Azure. Log in to Azure Active Directory Portal, and select "Enterprise applications" in the navigation panel. Click on "New application" Click on "Create your own application". In the panel on the right, enter an app name and select the "Integrate any other application you don't find in the gallery (Non-gallery)" option, and click "Create" in the bottom-left corner. Click on "Single sign-on" on the left pane, and select "SAML". Click on "Edit". **NOTE** Please note that the Identifier (Entity ID) value, along with the Single Sign-On URL, can be located within the SAML tab under the Account Management Settings section within the Blink Platform. The **Reply URL (Assertion Consumer Service URL)** is not available under the SAML tab, therefore you can find it below: **The Entity ID** : `urn:amazon:cognito:sp:eu-west-1_NEemCMO1L` **The Reply URL (Assertion Consumer Service URL)** : `https://cognito.blinkops.com/saml2/idpresponse` **Single Sign-On URL** : Please look in the Account Management Settings section within the Blink Platform to find your unique **Single Sign-On URL**. Using the Reply URL **(Assertion Consumer Service URL)**, as well as the **Identifier (Entity ID)** value as well as the **Single Sign-On URL** value located within the SAML tab under the Account Management Settings section within the Blink Platform, copy and paste the values in the following text fields as demonstrated in the image below: Next, scroll to the **Attributes & Claims** section and select the **add new claim** option in the top-left corner. Then under the **Additional Claims** section, ensure that the **claim names**, **type** and **value** correspond to the values as demonstrated in the image below: Proceed by clicking on the **groups claim** option and provide all the required information on the sidebar to the right. Then, complete the process by clicking on the "Save" button. # Configuring a SAML application on Cloudflare Source: https://docs.blinkops.com/docs/blink-platform/account-management/identity-providers/cloudflare Instructions on how to configure a SAML SSO application with Cloudflare. ## 1. Get SaaS Application URLs * **Entity ID**: A unique URL issued for your SaaS application. * **Assertion Consumer Service URL:** The service provider’s endpoint for receiving and parsing SAML assertions. **NOTE** Please note that the **Identifier (Entity ID)** value, along with the **Assertion Consumer Service URL**, can be located within the SAML tab under the Account Management Settings section within the Blink Platform. Please note the value of the **Assertion Consumer Service URL (ACS URL)** can be either the **Service Provider Login URL (SSO URL)** or **IdP-Initiated Login URL**. **The Entity ID** : `urn:amazon:cognito:sp:eu-west-1_NEemCMO1L` **Assertion Consumer Service URL:** [https://cognito.blinkops.com/saml2/idpresponse](https://cognito.blinkops.com/saml2/idpresponse). *** ## ​​2. Add your Application to Access Navigate to the **Zero Trust** option in the sidebar. Navigate to **application**. Select **Add an application**. Select SaaS. Enter a unique name in the Application field, like `BlinkOps`, and hit **Enter** since the `BlinkOps` application might not be included. Enter the **Entity ID** and **Assertion Consumer Service URL** obtained from your SaaS application account. **INFO** **The Entity ID** : `urn:amazon:cognito:sp:eu-west-1_NEemCMO1L` **Assertion Consumer Service URL**: [https://cognito.blinkops.com/saml2/idpresponse](https://cognito.blinkops.com/saml2/idpresponse). Select the **Name ID** Format expected by your SaaS application (usually Email). Scroll down to the **SAML attribute statements** section and add the following **key-value pairs**, and then click Next. **INFO** **IdP groups**\ If you are using Okta, AzureAD, Google Workspace, or GitHub as your IdP, Access will automatically send a SAML attribute titled groups with all of the user’s associated groups as attribute values. Configure **App Launcher settings** for the application — **this is an optional step.** Under **Block pages**, choose what end users will see when they are denied access to the application: * **Cloudflare default**: Reload the login page and display a block message below the Cloudflare Access logo. The default message is "That account does not have access", or you can enter a custom message. * **Redirect URL**: Redirect to the specified website. * **Custom page template**: Display a custom block page hosted in Zero Trust. Next, configure how users will authenticate: * Select the Identity providers you want to enable for your application. * (Optional) Turn on Instant Auth if you selected only one IdP and want users to skip the identity provider selection step. * (Optional) Under WARP authentication identity, allow users to authenticate to the application using their WARP session identity. Select Next. *** ## Add an Access Policy To control who can access your application, create an **Access policy**. Then navigate to the **Assign a group** section and fill out the following fields. Then head to the **SAML** tab under the **Account Management Settings** section within the Blink Platform and click the **Role Mapping** section and select the applicable values. **Note:** Please note that within the **mapping** section, it's necessary to designate at least one **mapping role** as an **admin** with administrative privileges. Otherwise, you will not have the ability to operate within your account as an **administrator**. *** ## 4. Configure SSO in your SaaS application Finally, you will need to configure your SaaS application to require users to log in through Cloudflare Access. Configure the following fields with your SAML SSO-compliant application: * SSO endpoint * Access Entity ID or Issuer * Public key **NOTE**\ The metadata is available at the URL: `/saml-metadata` Proceed by copying the contents of that file found at the URL: `/saml-metadata`. Then navigate to the **Metadata File section** found within the **SAML tab** in your **Account Management Settings** Paste the **contents of that file** into the designated text field labeled Metadata File. Then click **Save Settings** in the bottom-right corner. Your application will appear on the Applications page. *** # Configuring a SAML application on Google Workspace Source: https://docs.blinkops.com/docs/blink-platform/account-management/identity-providers/google Instructions on how to configure a SAML SSO application with Google Workspace. Log in to Google Admin account, press "Apps" on left sidebar, and under it "Web and mobile apps", then press in main window "Add app" and choose "Add custom SAML app": In "Add custom SAML app", give App name, and press continue: In the IdP page, click on the 'download metadata' button. Once the file is downloaded, navigate to the Metadata File section found within the SAML tab in the Account Management Settings. Paste the **downloaded metadata** values into the designated text field labeled Metadata File. **NOTE** Please note that the Identifier (Entity ID) value, along with the Single Sign-On URL, can be located within the SAML tab under the Account Management Settings section within the Blink Platform. The **ACS URL** is not available under the SAML tab, therefore you can find it below: **The Entity ID** : `urn:amazon:cognito:sp:eu-west-1_NEemCMO1L`\ **The ACS URL** : `https://cognito.blinkops.com/saml2/idpresponse`\ **Single Sign-On URL** : Please look in the Account Management Settings section within the Blink Platform to find your unique **Single Sign-On URL**. Using the **ACS URL**, as well as the **Identifier (Entity ID)** value and the **Single Sign-On URL** available in the SAML tab under the Account Management Settings section within the Blink Platform, proceed to copy and insert these values into the designated text fields below. **Note**: Paste the **Single Sign-On URL value** in the **START URL** text field. Press continue In the **Attribute mapping** page, map **"First name"** to **"given\_name"**, **Last name** to **family\_name**, and **"Primary email"** to **"email"**. Next, scroll to the **Group Membership** section, select your **Google Groups**, and set the App attribute value as **group** and click 'FINISH'. Then head to the SAML tab under the Account Management Settings section within the Blink Platform and click the **Role Mapping** section and select the applicable values. When a user belongs to multiple Google groups, Blink resolves role assignment in SAML SSO using a **top-down priority order** based on the `Group:Role` mapping table. The first matching group in the list determines the assigned role. **IMPORTANT** Please note that in the **Mapping** section, at least one mapping role must be designated as an **admin** with administrative privileges. Additionally, the user configuring the group must be a part of the group mapped to the **Admin** role. Otherwise you won't be able to operate as an administrator in your account or access and edit the role mapping again. After you finish SAML app creation, you can set up User access by changing the status to **ON** for all organizational units: # Account Security Settings Source: https://docs.blinkops.com/docs/blink-platform/account-management/identity-providers/identity-providers Set up and manage identity providers for single sign-on (SSO) authentication in Blink. This guide walks you through the key authentication and identity settings available in the Blink platform. From managing authorized domains and setting up external Identity Providers (IdPs), to configuring role mappings and enforcing SAML policies, each section helps you securely control user access and authentication behavior across your Blink environment. Start by accessing your account's security settings using the steps below. *** ## Access Account Settings Navigate to the security settings on the Blink platform. In the bottom-left corner click on the rounded icon with your initials on it. A dialogue box will appear, with your Blink Ops account settings: If you are part of more than one tenant, you have the option to switch between the tenants by selecting the tenant from the dynamic dropdown menu. *** ## Login & Authentication ### Authorized Domains A comma-separated list of domains allowed for IDP or username/password login. If not populated, any domain will be valid. **Note**: SAML authorized domains are configured in a separate section. Navigate [here](#saml-authorized-domains). *** ### Identity Provider Blink provides the option to configure an external Identity Provider to use within the Blink platform. Any SAML app can be connected to Blink. Blink provides templates for: * [Okta](/docs/blink-platform/account-management/identity-providers/okta) * [Google Workspace](/docs/blink-platform/account-management/identity-providers/google) * [Azure AD](/docs/blink-platform/account-management/identity-providers/azure) * [Cloudflare](/docs/blink-platform/account-management/identity-providers/cloudflare) *** ### Role Mapping Role Mapping is the method by which Blink synchronizes **Identity Providers** to the Blink platform. Please be aware that configuring **Role Mapping** varies depending on the **Identity Provider** you are using. Therefore, it's crucial to carefully follow the instructions tailored to your chosen **Identity Provider** when setting up **Role Mapping** **Note**: When mapping a Blink group to an Identity Provider (IdP), make sure the group is created in Blink before you configure the role mapping in the selected Identity Provider (IdP). Also, the name of the group in Blink must **match exactly** with the name of the group in the Identity Provider. **IMPORTANT**: Please note that in the **Mapping** section, at least one mapping role must be designated as an **admin** with administrative privileges. Additionally, the user configuring the group must be a part of the group mapped to the **Admin** role. Otherwise you won't be able to operate as an administrator in your account or access and edit the role mapping again. * [Okta Role Mapping-Step 8](/docs/blink-platform/account-management/identity-providers/okta) * [Google Role Mapping-Step 8](/docs/blink-platform/account-management/identity-providers/google) * [Azure AD](/docs/blink-platform/account-management/identity-providers/azure) * [Cloudflare](/docs/blink-platform/account-management/identity-providers/cloudflare) Role mapping rules are evaluated sequentially, the first matching rule determines the user’s assigned role mapping. You can easily adjust the evaluation order by clicking the icon and dragging each group to your preferred position. *** ### SAML Authorized Domains SAML Authorized Domains cannot be populated by the user Identity providers, for example [Okta](/docs/blink-platform/account-management/identity-providers/okta), do not independently validate domain ownership. As a result, customers requesting domain-related updates will contact Customer Support (CS) for assistance. CS will then verify that the requested domains are legitimately associated with the customer before applying any changes. This verification step is required to prevent impersonation and ensure that only authorized domains are linked to a customer’s identity provider configuration. *** ### SAML Session Lifetime Select the duration (in hours or days) a user can remain logged into their account before being automatically logged out and required to log in again. The default time out is `30` days. *** ### SAML Strict Mode Choose whether you would like to enable **SAML Strict Mode** by checking the box. When enabling **SAML Strict Mode**, all organization users who are not administrators must use **SAML** to sign in to Blink. Admins retain access to alternative sign-in modes for troubleshooting purposes. *** # Configuring a SAML application on Okta Source: https://docs.blinkops.com/docs/blink-platform/account-management/identity-providers/okta Instructions on how to configure a SAML SSO application with Okta. Log in to Okta, go to the admin dashboard, and select "Applications" in the navigation panel. Select "Create App Integration". Select "SAML 2.0" and click 'Next'. Enter an "App Name" and click Next. Please note that the **IdP-Initiated Login URL**, **Service Provider ID (SP Entity ID)**, **Service Provider Login URL (SSO URL)** and **Service Provider Logout URL (SLO URL)** can be located within the SAML tab under the Account Management Settings section within the Blink Platform. **IdP-Initiated Login URL** : Please look in the Account Management Settings section within the Blink Platform to find your unique **IdP-Initiated Login URL**. **Service Provider ID (SP Entity ID)** : urn:amazon:cognito:sp:us-east-1\_Nu63sypSS **Service Provider Login URL (SSO URL)** : `https://cognito.blinkops.com/saml2/idpresponse` **Service Provider Logout URL (SLO URL)** : `https://cognito.blinkops.com/saml2/logout` **Please Note** users who use on-premise deployment, please **do not** use the above values to complete the **Create SAML Integration** section of the Okta application, instead you should login to your **own** on-premise deployment app and use the unique values provided in the **SAML** tab under the **Account Management Settings**. Using the unique **IdP-Initiated Login URL** available in the SAML tab under the Account Management Settings section within the Blink Platform, proceed to the **Create SAML Integration** section of the application and copy and paste the URL value in the **Single Sign-On URL** text field. Then copy and paste the **Service Provider Login URL (SSO URL)** value in **both** the **Recipient URL** text field and the **Destination URL** text field. Lastly copy and paste the **Service Provider ID (SP Entity ID)** value in the **Audience URI (SP Entity ID)** text field. Scroll down to the “Attribute Statements” section and add the following key-value pairs, and then click Next. Then scroll down to the "Group Attribute Statement" section and fill out the following fields like portrayed in the following image: The error message in the image indicates: **"Invalid SAML response received: The value of the attribute custom:groups must have a length less than or equal to 2048 characters."** ### Cause of the Error: This error occurs because the **SAML response from the client's Identity Provider (IdP)** includes a `custom:groups` attribute whose **total character length exceeds AWS Cognito's 2048-character limit** for string attributes. In this specific case: * The client configured **group mapping using a wildcard**, which sends **all the user's group memberships** via SAML. * As a result, Cognito receives a very long string of group names combined, pushing the total value over the 2048-character limit. * Cognito then **rejects the login attempt**, since it cannot store or process that oversized attribute. *** ### Recommended Solution: To fix this, **stop using wildcard group mapping** and instead implement **manual group mapping** in the IdP SAML configuration. #### What to do: * The client should **explicitly map only the relevant groups** required by Blink, such as: * `Blink Builders` * `Blink Users` * `Blink Admins` * This will **limit the number and size** of the groups included in the SAML assertion, ensuring the `custom:groups` attribute stays within Cognito’s size constraints. Using wildcards (e.g., `*`) sends **all** group memberships, including unrelated or nested ones. This makes it unpredictable and highly prone to exceeding limits,especially in large organizations. This change needs to be made **in the client’s IdP application settings**, not in Blink or Cognito itself. Then head to the **SAML** tab under the **Account Management Settings** section within the Blink Platform and click the [Role Mapping](/docs/blink-platform/account-management/identity-providers/identity-providers#role-mapping) section and select the applicable values. When a user belongs to multiple Okta groups, Blink resolves role assignment in SAML SSO using a **top-down priority order** based on the `Group:Role` mapping table. The first matching group in the list determines the assigned role. Please note that in the **Mapping** section, at least one mapping role must be designated as an **admin** with administrative privileges. Additionally, the user configuring the group must be a part of the group mapped to the **Admin** role. Otherwise you won't be able to operate as an administrator in your account or access and edit the role mapping again. Select “I’m an Okta customer adding an internal app” from the options menu, and then click Finish. To give users permission to authenticate via this SAML app, you will need to assign users or groups. Click on the "Assignments" tab and assign the users or groups you require. Click on the "Sign On" tab and scroll down to the "SAML Signing Certificates". Click on "View SAML setup instructions". Next, under the **Optional** section at the bottom, copy the **IDP metadata** values. Next, navigate to the **SAML** section found within the SAML tab in the Account Management Settings. Paste the **IDP metadata** values into the designated text field labeled 'Metadata File'. # Resetting your password Source: https://docs.blinkops.com/docs/blink-platform/account-management/resetting-your-password Instructions about how to reset your password if you have forgotten it If you forget your password you can easily renew it. 1. On the log-in page, click **Forgot Password**. You will be redirected to the **Forgot password** page. 2. Enter the email address that is associated with your Blink account and click **Submit**. An email will be sent to your inbox. 3. Go to your inbox, open the email from Blink, and click **Reset password**. You will be redirected to the **Reset password** page. If you didn't receive an email, click **Send Again**. 4. Enter a new password, confirm the password, and click **Log in**. *Your password has been changed successfully* appears. 5. Click **Log in** and log in with your new password. # RBAC and User Roles Source: https://docs.blinkops.com/docs/blink-platform/account-management/roles Understand and configure user roles and permissions within your Blink organization. In the Blink Platform, access permissions to Blink resources and their functionality are managed through Role-based Access Control (RBAC) and User Roles. Blink Users are assigned User Roles based on two distinct scopes: the [Tenant scope](#tenant-user-role-scope) and the [Workspace Scope](#workspaces-user-role-scope). The Tenant scope covers permissions across the entire tenant, while the Workspace scope focuses on permissions within individual workspaces. Each role has its own set of predefined roles and permissions. Every Blink user has at least one Tenant Role and a separate Workspace role for each workspace they are part of. User Roles can differ between workspaces; for example, you might be an Owner in one workspace and a Contributor in a different workspace. Additionally, you have the option to [create your own custom user roles](#adding-a-new-role). *** ## Important Key Terms to Understand: RBAC, Scopes and User Roles 1. **Role-Based Access Controls (RBAC)** is a system that limits network access based on an individual's role within an organization. It involves assigning permissions and privileges to ensure users have the appropriate level of access according to their roles and responsibilities. 2. **Scopes** - A scope defines where specific tasks a [user](/docs/blink-platform/account-management/accounts#users) or [service account](/docs/blink-platform/account-management/accounts#accounts) in an organization can be performed. 3. **User Roles** are aggregations of scopes that define what tasks a user can perform based on the access permissions assigned to their role within the organization. *** ## Tenant Role Scope Under the **Tenant Role Scope**, you can be assigned a built-in user role as an [Admin](#admin), [Builder](#builder), [Consumer](#consumer), [Tenant Guest](#tenant-guest) or any custom user role created in your Tenant scope. ### 1. Admin As an Admin, you have full access to all Workspaces and control over all **tenant** settings. Please note that users assigned an [Admin Role in the Tenant Scope ](#1-admin) have editing permissions across **all** tenant workspaces.
| Feature | Description | Permissions | | ---------------- | ----------------------------------- | ----------------------- | | Account Settings | View entities and settings | account:view | | Account Settings | Invite users to the account | account:invite | | Account Settings | Manage own API keys | account:api\_keys:edit | | Account Settings | Create entities and update settings | account:edit | | Blink Portal | View Apps | portal:app:view | | Blink Portal | View Agents | portal:agent:view | | Blink Portal | View Services | portal:service:view | | Blink Portal | Execute Apps | portal:app:execute | | Blink Portal | Execute Agents | portal:agent:execute | | Blink Portal | Execute Services | portal:service:execute | | Workspaces | View Workspaces | workspace:view | | Workspaces | View Personal Workspace | workspace:view:personal | | Workspaces | Create Workspaces | workspace:create |
*** ### 2. Consumer As a Consumer, you have Blink Portal read and execute access only. #### Blink Portal
| Feature | Description | Permissions | | ------------ | ---------------- | ---------------------- | | Blink Portal | View Apps | portal:app:view | | Blink Portal | View Agents | portal:agent:view | | Blink Portal | View Services | portal:service:view | | Blink Portal | Execute Apps | portal:app:execute | | Blink Portal | Execute Agents | portal:agent:execute | | Blink Portal | Execute Services | portal:service:execute |
*** ### 3. Builder As a Builder, you have access to workspaces you are a member of and have full access to the Self Service Portal.
| Permissions | Description | Feature | | ---------------- | ----------------------- | ----------------------- | | Account Settings | Manage own API keys | account:api\_keys:edit | | Blink Portal | View Apps | portal:app:view | | Blink Portal | View Agents | portal:agent:view | | Blink Portal | View Services | portal:service:view | | Blink Portal | Execute Apps | portal:app:execute | | Blink Portal | Execute Agents | portal:agent:execute | | Blink Portal | Execute Services | portal:service:execute | | Workspaces | View Workspaces | workspace:view | | Workspaces | View Personal Workspace | workspace:view:personal | | Workspaces | Create Workspaces | workspace:create |
*** ### 4. Tenant Guest As a Tenant Guest, you have only access permissions to view Workspaces.
| Permissions | Description | Scope | | ----------- | --------------- | -------------- | | Workspaces | View Workspaces | workspace:view |
*** ## Workspaces Role Scope Under the **Workspace Role Scope**, you can be assigned a built-in role as an [Owner](#owner), [Contributor](#contributor), [Viewer](#viewer) or [Case Management Guest](#case-management-guest) or any custom Workspace user role created in your Tenant. To assign a user a **Workspace Role**, follow these [instructions](/docs/blink-platform/account-management/workspace-management#manage-members). ### 1. Owner As an owner, you have full access to the workspace and workspace settings.
| Feature | Description | Permissions | | -------------------- | --------------------------------------------------------------- | ----------------------------- | | Agents and Workflows | Read-only access to workflow and agent configurations | agent\_workflow:view | | Agents and Workflows | Execute workflows or interact with agents | agent\_workflow:execute | | Agents and Workflows | Create, modify, and configure workflow steps or agent behaviors | agent\_workflow:edit | | Agents and Workflows | Publish workflows and agents changes | agent\_workflow:publish | | Agents and Workflows | Review and approve workflow changes | workflow:approve | | Agents and Workflows | Publish approved workflows | workflow:publish\_approved | | Agents and Workflows | Share workflows and agents to portal | agent\_workflow:portal\_share | | Case Management | View existing cases | case\_management:view | | Case Management | Create and edit cases. | case\_management:edit | | Case Management | Close cases. | case\_management:close\_case | | Case Management | Delete Cases. | case\_management:delete\_case | | Case Management | Manage case management settings. | case\_management:admin | | Connections | View existing connections | connections:view | | Connections | Create and edit connections | connections:edit | | Dashboards | View existing dashboards | dashboard:view | | Dashboards | Share dashboards to portal | dashboard:portal\_share | | Dashboards | Create and edit dashboards | dashboard:edit | | Global Variables | View existing global variables | global\_variables:view | | Global Variables | Create and edit global variables | global\_variables:edit | | Runners | View existing runners | runners:view | | Runners | Create and edit runners | runners:edit | | Tables | View existing tables | tables:view | | Tables | Execute actions and responses | tables:execute | | Tables | Create and edit tables | tables:edit | | Workflows | View existing workflows | Workflow:view | | Workflows | Execute workflows | workflow:execute | | Workflows | Share workflows to portal | workflow:portal\_share | | Workflows | Create and edit workflows | workflow:edit | | Workflows | Can Publish Approved Workflows | workflow:publish\_approved | | Workflows | Approve Workflows | workflow:approve | | Workflows | Publish Workflows | workflow:publish | | Workspaces | Share workspaces resources | workspaces:share | | Workspaces | Update workspace settings | workspaces:edit | | Workspaces | Delete workspaces | workspaces:delete |
*** ### 2. Contributor As a contributor, you have full access to the workspace, but without access to the workspace settings.
| Feature | Description | Permissions | | -------------------- | --------------------------------------------------------------- | ----------------------------- | | Agents and Workflows | Read-only access to workflow and agent configurations | agent\_workflow:view | | Agents and Workflows | Execute workflows or interact with agents | agent\_workflow:execute | | Agents and Workflows | Create, modify, and configure workflow steps or agent behaviors | agent\_workflow:edit | | Agents and Workflows | Publish workflows and agents changes | agent\_workflow:publish | | Agents and Workflows | Review and approve workflow changes | workflow:approve | | Agents and Workflows | Publish approved workflows | workflow:publish\_approved | | Agents and Workflows | Share workflows and agents to portal | agent\_workflow:portal\_share | | Case Management | View existing cases | case\_management:view | | Case Management | Create and edit cases. | case\_management:edit | | Case Management | Close cases. | case\_management:close\_case | | Case Management | Delete Cases. | case\_management:delete\_case | | Case Management | Manage case management settings. | case\_management:admin | | Connections | View existing connections | connections:view | | Connections | Create and edit connections | connections:edit | | Dashboards | View existing dashboards | dashboard:view | | Dashboards | Share dashboards to portal | dashboard:portal\_share | | Dashboards | Create and edit dashboards | dashboard:edit | | Global Variables | View existing global variables | global\_variables:view | | Global Variables | Create and edit global variables | global\_variables:edit | | Runners | View existing runners | runners:view | | Runners | Create and edit runners | runners:edit | | Tables | View existing tables | tables:view | | Tables | Execute actions and responses | tables:execute | | Tables | Create and edit tables | tables:edit | | Workflows | View existing workflows | workflow:view | | Workflows | Execute workflows | workflow:execute | | Workflows | Share workflows to portal | workflow:portal\_share | | Workflows | Create and edit workflows | workflow:edit | | Workflows | Can Publish Approved Workflows | workflow:publish\_approved | | Workflows | Approve Workflows | workflow:approve | | Workflows | Publish Workflows | workflow:publish | | Workspaces | Share workspace resources | workspaces:share |
*** ### 3. Viewer As a viewer, you can only observe the mentioned features without the ability to edit or create them.
| Feature | Description | Permissions | | -------------------- | ----------------------------------------------------- | ---------------------- | | Agents and Workflows | Read-only access to workflow and agent configurations | agent\_workflow:view | | Case Management | View existing cases | case\_management:view | | Connections | View existing connections | connections:view | | Dashboards | View existing dashboards | dashboard:view | | Global Variables | View existing global variables | global\_variables:view | | Runners | View existing runners | runners:view | | Tables | View existing tables | tables:view | | Workflows | View existing workflows | workflow:view |
*** ### 4. Case Management Guest As a Case Management Guest, you have access permissions to specific cases within Case Management.
| Feature | Description | Scope | | --------------- | ---------------------------------------------------------------------------------------- | --------------------------- | | Case Management | Edit only the cases shared with the user and their groups, including any linked entities | case\_management:restricted |
*** ## Adding a New Custom Role 1. In the top-right corner, click the **New Role** button. 2. A dialogue box will open, displaying all **user role permissions**. 3. Add a **Role Name** and a **Role Description**. 4. Select a **Role Scope** by selecting between a **Tenant Role** or a **Workspace Role** from the dynamic dropdown. Please note that **Tenant Role** or a **Workspace Role** have different access permissions
| **Feature** | **Permission** | **Description** | | -------------------- | ------------------------- | --------------------------------------- | | **Account settings** | `account:view` | View entities and settings | | | `account:invite` | Invite users to the account | | | `account:edit` | Create entities and update all settings | | **Blink Portal** | `portal:app:view` | View apps | | | `portal:service:view` | View services | | | `portal:app:execute` | Execute apps | | | `portal:service:execute` | Execute services | | **Workspaces** | `workspace:view` | View user’s associated workspaces | | | `workspace:view:personal` | Access user’s personal workspace | | | `workspace:create` | Create workspaces |
| Feature | Permission | Description | | -------------------- | ---------------------------- | ------------------------------------------------------------------------------------------------- | | **Case Management** | `case_management:restricted` | View and edit only the cases shared with the user and their groups, including any linked entities | | | `case_management:view` | View existing cases | | | `case_management:edit` | Create and edit cases | | | `case_management:close_case` | Close cases | | | `case_management:delete` | Delete case management entities | | | `case_management:admin` | Manage case management settings, including editing a case, closing a case, and deleting a case | | **Connections** | `connection:view` | View existing connections | | | `connection:edit` | Create and edit connections | | **Dashboards** | `dashboard:view` | View existing dashboards | | | `dashboard:edit` | Create and edit dashboards | | **Global Variables** | `global_variable:view` | View existing global variables | | | `global_variable:edit` | Create and edit global variables | | **Runners** | `runner:view` | View existing runners | | | `runner:edit` | Create and edit runners | | **Tables** | `table:view` | View existing tables | | | `table:edit` | Create and edit tables | | **Workflows** | `workflow:view` | View existing workflows | | | `workflow:execute` | Execute workflows | | | `workflow:edit` | Create and edit workflows | | | `workflow:publish` | Publish workflows | | | `workflow:approve` | Review and approve workflow changes | | | `workspace:share` | Share workspace resources | | | `workspace:edit` | Update workspace settings | | | `workspace:delete` | Delete workspace |
***
5. Then, select the relevant checkboxes to customize user role permissions and then click the **create** icon. # PRIVACY POLICY Source: https://docs.blinkops.com/docs/blink-platform/account-management/security-and-legal/privacy-policy Blink Ops privacy policy covering data collection, usage, and protection practices. # PRIVACY POLICY IMPORTANT: BY USING BLINK OPERATIONS INC.'S AND ITS AFFILIATES ("**Blink**" OR "**WE**") SERVICES AND WEBSITE (THE "**SERVICES**") YOU CONSENT TO THE TERMS AND CONDITIONS OF THIS PRIVACY POLICY AND CONSENT THAT ALL PERSONALLY IDENTIFIABLE INFORMATION ("**PII**") THAT YOU SUBMIT OR THAT IS PROCESSED OR COLLECTED THROUGH THE SERVICES MAY BE PROCESSED BY BLINK IN THE MANNER AND FOR THE PURPOSES DESCRIBED IN THE FOLLOWING PRIVACY POLICY. Any capitalized terms not defined herein shall have such meaning ascribed to them in the Blink Terms of Service. We recognize that privacy is important. This policy applies to all of the software, services, information, tools, features and functionality available on the Services offered by Blink or its subsidiaries or affiliated companies and covers how PII that Blink collects and receives, including in respect of any use of the Services, is treated. If you have any questions about this policy, please feel free to contact us using the contact details published on our Services or directly at [privacy@blinkops.com](mailto:privacy@blinkops.com). IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS SET FORTH HEREIN PLEASE DO NOT USE THE SERVICES. 1. **Information We Collect and How We Use It. In order to provide and improve our Services, we may collect PII, including the following types of information:** * **Information You Provide.** When you subscribe to the Services or otherwise during the Account creation process, we ask you for personal information, including full name, email address, professional affiliation and other information you may provide. * **User Communications.** When you send an email or other communication to Blink, we may retain those communications in order to process your inquiries, respond to your requests and improve our Services. We may send you push notifications to send you news and updates in respect of the Services. We may also send you newsletters and promotional communications, you may opt-out of this service at any time by unsubscribing in the link provided in such communications. * **Aggregated and Analytical Data.** In an ongoing effort to better understand and serve the users of the Services, Blink often conducts research on its users demographics, interests and behavior based on the PII and other information provided to us. This research may be compiled and analyzed on an aggregate basis, and Blink may share this aggregate data with its affiliates, agents and business partners. This aggregate information does not identify you personally. Blink may also disclose aggregated user statistics in order to describe our services to current and prospective business partners, and to other third parties for other lawful purposes. * **User Activity.** When you use the Services, we may automatically receive and record technical information regarding the method and nature of your use of the Services and information from your browser, including without limitation information and statistics about your search activity, session times, impressions, pages visited, online/offline status, IP address, internet service provider, type of browser, regional and language settings and software and hardware attributes, unique device identifier, advertising identifier and location (including geolocation, beacon based location, and GPS location). An IP address is a numeric code that identifies your browser on a network, or in this case, the Internet. Your IP address is also used to gather broad demographic information. Blink uses all of the PII that we collect to understand the usage trends and preferences of our users. 2. **Cookies; web beacons and third party processors.** In order to collect the data described herein, support your login and identify you, we may use temporary cookies that remain on your device for a limited period of time. We may also use persistent cookies that remain on your device until manually removed in the settings of your device/browser, in order to manage and maintain the services and record your use of the Services. Cookies by themselves cannot be used to discover the identity of the user. A cookie is a small piece of information which is sent to and stored on your device. Cookies do not damage your device. Most browsers or devices may allow you to block cookies but you may not be able to use some features on the Services if you block them. You may set most browsers to notify you if you receive a cookie (this enables you to decide if you want to accept it or not). We may also use web beacons via the Services to collect information. Web beacons or "gifs", are electronic images that may be used in our Services or in our emails. We use Web beacons to deliver cookies, count visits and to tell if and when an email has been opened and acted upon. We also use third party tracking technologies, such as cookies and web beacons and various third party providers to process and analyze your PII, profile end user activities and provide targeted ads, including without limitation tracking your use of the Services and third party services and site 3. **Links.** Links to other services, sites and applications may be provided by Blink as a convenience to our users. Blink is not responsible for the privacy practices or the content of other sites and applications and you visit them at your own risk. This privacy statement applies solely to PII collected by us. 4. **Minors.** If you are a minor under the age of 18, you must obtain parental consent prior to using our Services. Blink will not knowingly contact or engage with minors under the age of 18 without said parental consent. If you have reason to believe that a child has provided us with their PII, please contact us at the address given above and we will endeavor to delete that PII from our databases. 5. **Information Sharing.** As part of providing the Services and/or generating and processing analytics, our affiliates, agents representatives and third party providers may have access to your PII. Blink may also share PII in the following circumstances: (a) as required for the provision, maintenance and improvement of the Services; (b) if we become involved in a reorganization, merger, consolidation, acquisition, or any form of sale of some or all of our assets (which sale may be to an entity registered or incorporated in a different jurisdiction than Blink); and/or (c) to satisfy applicable law or prevention of fraud or harm or to enforce applicable agreements and/or their terms, including the Terms of Services, including investigation of potential violations thereof 6. **Information Security.** We follow generally accepted industry standards to protect against unauthorized access to or unauthorized alteration, disclosure or destruction of PII. However, no method of transmission over the Internet, or method of electronic storage, is 100% secure. Therefore, while we strive to use commercially acceptable means to protect your PII, we cannot guarantee its absolute security. We keep your PII only for as long as reasonably necessary for the purposes for which it was collected or to comply with any applicable legal or ethical reporting or document retention requirements 7. **Data Integrity, Accessing and Updating Personal Information.** Blink processes PII only for the purposes for which it was collected and in accordance with this policy or any applicable service agreements. We review our data collection, storage and processing practices to ensure that we only collect, store and process the PII needed to provide or improve our Services. We take reasonable steps to ensure that the PII we process is accurate, complete, and current, but we depend on our users to update or correct their PII whenever necessary. Nothing in this policy is interpreted as an obligation to store information, and we may, at our own discretion, delete or avoid from recording and storing any and all information. 8. **Your Rights.** * **Right of Access and Rectification.** You have the right to know what PII we collect about you and to ensure that such data is accurate and relevant for the purposes for which we collected it. We allow our users the option to access and obtain a copy of their PII and to rectify such PII if it is not accurate, complete or updated. However we may first ask you to provide us certain credentials to permit us to identify your PII. * **Right to Delete PII or Restrict Processing.** You have the right to delete your PII or restrict its processing. We may postpone or deny your request if your PII is in current use for the purposes for which it was collected or for other legitimate purposes such as compliance with legal obligations. * **Right to Withdraw Consent.** You have the right to withdraw your consent to the processing of your PII. Exercising this right will not affect the lawfulness of processing your PII based on your consent before its withdrawal. * **Right of Data Portability.** Where technically feasible, you have the right to ask to transfer your PII in accordance with your right to data portability. You may exercise the above rights by sending a request to [privacy@justBlink.com](mailto:privacy@justBlink.com). * **Right to Request Information on Transfers.** You have the right to request certain details of the basis on which your PII is transferred outside the European Economic Area. Please be aware that certain information relating to such transfers may be partially redacted or restricted due to data transfer agreements or reasons relating to commercial confidentiality. * **Right to Lodge Complaint.** You also have the right to lodge a complaint with a data protection supervisory authority regarding the processing of your PII 9. **Enforcement.** Blink regularly reviews its compliance with this policy. Please feel free to direct any questions or concerns regarding this policy or our treatment of PII by contacting us as provided above. When we receive formal written complaints it is Blink's policy to contact the complaining user regarding his or her concerns. We will cooperate with the appropriate regulatory authorities, including local data protection authorities, to resolve any complaints regarding the transfer of PII that cannot be resolved between Blink and an individual 10. **Changes to This Privacy Policy.** Blink may update this policy. We will notify you about significant changes in the way we treat PII by sending a notice to the primary email address specified in your account or by placing a prominent notice on the Services. We encourage you to periodically review this policy for the latest information about our privacy practices 11. **Consent To Processing.** By providing any PII to us pursuant to this policy, all users, including, without limitation, users in the United States, Israel and member states of the European Union, fully understand and unambiguously consent to this policy and to the collection and processing of such PII abroad. The server on which the Services are hosted and/or through which the Services are processed may be outside the country from which you access the Services and may be outside your country of residence. Some of the uses and disclosures mentioned in this policy may involve the transfer of your PII to various countries around the world that may have different levels of privacy protection than your country. By submitting your PII through the Services, you consent, acknowledge, and agree that we may collect, use, transfer, and disclose your PII as described in this policy. If you do not consent to the terms of this policy, please do not use the Services 12. **Questions.** If you have any questions about this policy or concerns about the way we process your PII, please contact us using the contact details published on our Services. If you wish to delete all information regarding your use of the Services, please contact us at [privacy@blinkops.com](mailto:privacy@blinkops.com) 13. **Your California Privacy Rights and Do Not Track Notices.** California Civil Code Section 1798.83 permits customers of Blink who are California residents to request certain information regarding its disclosure of PII to third parties for their direct marketing purposes. To make such a request, please contact us at [privacy@blinkops.com](mailto:privacy@blinkops.com). Please note that we are only required to respond to one request per customer each year. You are also advised that Blink does not respond to “Do Not Track” signals # Security Statement Source: https://docs.blinkops.com/docs/blink-platform/account-management/security-and-legal/security-statement Blink Ops security statement outlining platform security measures and compliance standards. This document addresses the security implications of a Blink hybrid deployment where the Runner is self-hosted (on-premises), but other aspects of the platform are performed by the SaaS controller. This document shows how the Blink platform may be incorporated into any cloud environment, while keeping customer's cloud environment secured. ## Security principles **Minimal trust methodology** Blink has adopted a minimal trust methodology to keep customers as independent as possible from Blink when it comes to their security posture. Blink is designed to serve as an abstraction & automation level over existing SaaS services that are being used by the customers, and by that prevents granting power/trust to Blink to take actions on customer’s behalf. **Data security** To create a secure environment for users, data security measures in all aspects are taken. Security of data in transit, stored data, secured backups, strict data access principles, cloud security posture etc. have been taken into account during the creation and maintenance of the Blink platform. **Role-based access control (RBAC)** Blink allows granular RBAC permission management, using roles, permissions, workspaces, groups, and resources. Using Blink’s RBAC, customers are able to import existing permissions of users from their existing SaaS permissions, as well as utilizing different authorization approaches under RBAC within the account. ## Data security Blink SaaS data flow diagram **Data in rest** Data stored at rest on Blink premise, will always be stored at an encrypted state. When using Blink's hybrid model, the following data types are stored in Blink SaaS premise: * Account metadata * User details * Automation content * Resources names & types * Logs of Automation executions Blink does not store the customers secrets when using hybrid deployment. Credentials are stored using Hashicorp’s vault. **Data in transit** All in-transit data on the Blink platform and external dependencies, is sent over TLS encrypted networking / industry-standard encryption methodologies. In addition to the data kept at rest on the Blink platform, additional data is forwarded using Blink SaaS to the customer’s utilization through the UI. This data includes: * User credentials * Users Automations * Step outputs ## Main security measures **Customer identity** Any action performed by Blink users is signed by a JWT token. The identity token is generated by an external authentication provider and is validated through the customer’s request. By enforcing the performed action signature, Blink mitigates the risk of Man In Middle and Request forgery attack vectors. **Credentials Security** (Credentials Jail) 1. Blink is relying on external credentials in order to allow users to integrate and interact with external SaaS services. To avoid dangers related to credentials, Blink on-prem solution allows the user to keep all credentials usage on-premise. Blink will integrate to the customer’s secret manager. Currently supported secret managers include Hashicorp Vault and AWS Secret Manager. 2. Usage of credentials on a runner-based system where running code is allowed, imposes the risk of credentials leaking - either by accident or by adversary action. Blink mitigates this risk by applying a Credentials jail - credentials are exposed only to pre-built and acknowledged system actions, rather than being directly exposed to arbitrary usage. **RBAC permissions management** Blink allows granular RBAC permission management, using roles, permissions, workspaces, groups, and resources. Using Blink’s RBAC, customers are able to import existing permissions of users from their existing SaaS permissions, as well as utilizing different authorization approaches under RBAC within the account. ## Additional security measures **Environment Isolation** Blink offers two run modes in terms of isolation: 1. **Shared environment** - Use the main Blink cloud service, which is shared across multiple accounts. Data is separated by per-tenant separation. 2. **Dedicated SaaS namespace** - Network, data flow, data storage and all business logic is completely separated at this mode. Data is separated on a DB per customer basis. **High availability and DDOS protection** The entire stack of Blink service is served on a highly available Kubernetes service. All components shown in the data flow diagram are protected by high availability measures, including crash-recovery. Additionally, all services are protected against OWASP and DDOS. **Backups** Data stored on Blink premise is backed up multiple times every day at an encrypted state. Customers may request for their backup data to be deleted, according to GDPR regulations. **Audits and logs** All metadata for actions performed on an account is kept for a minimal duration of 6 months, and is accessible by customer's request. ## Security & Privacy policies and standards In addition to the security measures detailed in this document, Blink acts upon the highest industry standards on security topics. Blink can provide documentation related to these topics at the customer's request. These topics include the following: 1. Compliance 2. Password management 3. Permission access management 4. Privacy policy 5. Risk assessment 6. Third-party vendor management 7. Key management and information security 8. Incident response 9. Auditing 10. Environment security 11. Data retention and erasure 12. Backup policy 13. Endpoint security # About the Blink Platform Source: https://docs.blinkops.com/docs/blink-platform/blink-platform In the Blink Platform section of the documentation, you can find all the necessary information related to the Blink Platform and its features.
Learn how to create and manage tables. Visualize data with custom dashboards. Automate workflows through the Blink Portal Manage user accounts and permissions.
### Blink Platform Navigation When a new user first enters Blink, a personal [workspace](#workspaces) is automatically created. In the left-hand navigation bar at the top, you'll find all the essential features of your workspace. The top section of the navigation bar features the main workspace features: [Workflows](/docs/workflows/workflows), [Tables](#tables), [Dashboards](#dashboards), [Workspace Settings](#workspaces) and [Cases](#cases) (when enabled in your workspace settings) Under [Workflows](/docs/workflows/workflows) you'll find a nested submenu with the following pages : [Connections](/docs/workflows/building-workflows/connections/connections), [Global Variables](#global-variables), [Runners](#runners), [Executions](/docs/workflows/monitoring-workflows-health#past-executions), and [Templates](#templates). **Tenant-level** information is found at the bottom of the navigation bar. Here, you can access the [Overview Dashboards](#blink-platform), the [Self-Service Portal](#self-service-portal), [Approval Management](/docs/workflows/managing-workflows/publish-approval/publish-approval), and [Account Settings](/docs/blink-platform/account-management/account-management). Just click on the feature you wish to access. ### Workspaces `Workspaces` enables you to create data-segregated and separate workspaces for different teams across your company, as well as, for different use cases. Every team can have one or more workspaces. This enables team members to collaborate on projects and share automated workflows and resources efficiently. All the workflows of a Workspace appear on the Workflows Pack page. See [Workspaces](/docs/blink-platform/workspaces/workspaces) for more details. ### Runners The Runner serves as the essential element in executing all actions within a Workflow. It offers the flexibility of deployment either on the Blink cloud infrastructure or within your own environment. To enhance scalability and distribute the workload efficiently, you have the option to create a runner group that can incorporate multiple instances of the runner. ### Tables Tables enable you to present and interact with data in Blink, unlocking new Workflow possibilities. Since your Workflow can write to Tables and read data from them, this enables you to create stateful workflows. See the [Tables](/docs/blink-platform/tables/tables) for more details. ### Dashboards Dashboards are visual interfaces for presenting data in Tables across the Blink Platform. ### Self-service Portal Blink enables you to create Workflows that streamline workflows, and securely share them with other teams and workspaces. Users granted access can easily use the Workflows and move on to the next important job, without waiting for someone to create or do a task for them. You can use any existing Automation that is shared with (exposed to) you. All Workflows that are shared with you are listed in your Self-service portal. The `Self-service Portal` cuts out the middle-man enabling a more efficient work process. Visit the [Blink Portal](/docs/blink-platform/blink-portal/blink-portal#approvals-and-requests) for more details. ### Web forms The **Web Form** feature is vital for collecting user input through a **sharable web form**. The **web form** can be sent in the middle of the Workflow so it can incorporate data from previous steps. It can also affect the subsequent steps of the workflow. Users can tailor the form as desired and easily share it with other users via a link. Visit the [Web Forms](/docs/blink-platform/web-form/web-form) for more details. ### Account Management Everything related to Account Management and Account Settings can be found in this section. Visit the [Account Management](/docs/blink-platform/account-management/account-management) for more details. ### Service Providers and Tenant Management Blink customers have the option to designate a Service Provider (MSP, MSSP) to oversee the management of their account. By doing so, the Service Provider can develop customized Workflows tailored to the specific needs of the end-users, as well as manage and update them to guarantee a reliable and secure workspace. Moreover, the Service Provider can promptly address any issues that may arise, ensuring uninterrupted operations and a seamless user experience. Visit the [Service Providers and Tenant Management](/docs/blink-platform/service-providers/service-providers) for more details. # Blink Bot For Slack Source: https://docs.blinkops.com/docs/blink-platform/blink-portal/blink-bot-for-slack Use the Blink bot for Slack to run self-service portal workflows directly from your Slack workspace. ## Using the Self-service Portal via Slack Blink has created bot for Slack to seamlessly execute apps available in the Self-service portal directly from your Slack environment. Every Workflow that is exposed in the portal is automatically exposed to the bot for Slack. Please note only admins can connect the Blink Bot for Slack ## Connecting Slack to the Blink platform To run workflows directly from Slack, you need to connect your Slack workspace to your Blink account. Follow these steps: 1. In the Blink Platform, go to the bottom left corner and click your profile icon (a colored circle with your initials). 2. Navigate to **General**, then scroll to the **Bot for Slack** section. Click **Connect to Slack**. 3. A permission request dialog will appear, asking for access to your Slack workspace. 4. Click **Allow** to grant permission. Once connected, you’ll see **Connected to Slack** in your account settings. ## Executing a Workflow via Slack 1. In any channel or conversation, enter ***/***. Select **Portal** from the drop down menu. 2. If you are not logged in to the Blink platform, you will receive a message to **Go to login page**. Click **Go to login page** and log in to Blink. If you logged in successfully, **Thanks for logging in** will appear on your Slack feed. 3. Enter ***/portal*** and click **Self service portal request**. A list of all items available in the Self-service portal is displayed. 4. Click on any item in the portal. You will receive a message that the Workflow is running. If the Workflow needs input parameters, you will be prompted to enter them before running. The Blink bot will notify you of your request, the Workflow state and its results. # The Blink Portal Source: https://docs.blinkops.com/docs/blink-platform/blink-portal/blink-portal Overview of the Blink Portal for sharing workflows, dashboards, and self-service automation with your team. The Blink Portal is an interface which allows users to execute workflows with a single click, view and export dashboards effortlessly, and tap into the full suite of resources your teams have built, right from one streamlined interface. **Note**: Although you can run and interact with workflows and dashboards in the Blink Portal, you cannot modify any of the workflows or dashboards displayed there. *** ## Customize the Blink Portal Logo and Header 1. To customize your Blink Portals Logo and Header, navigate to your [General Settings](/docs/blink-platform/account-management/general) 2. Upload your custom logo and update the portal header as needed, then save your changes. Once saved, your updates will be automatically applied to the Blink Portal’s header and logo. *** **The Blink Portal is separated into two separate tabs:** For detailed guidance on Workflows, see our [Workflows Documentation](/docs/workflows/workflows). In the **Services** tab of the Blink Portal, you can access all **published** and **active** workflows available in your tenant: * **Filter by workspace:** Narrow down workflows based on the workspace they belong to. * **Filter by tags:** View workflows according to the tags assigned to them. * **Search bar:** Quickly locate a specific workflow by name or keyword. Once you find the workflow you want, enter any required input parameters and the run the workflow. *** ## Blink Portal Activity The Blink Portal makes it easy to review and monitor all workflow executions associated with your account. To access your workflow activity history, open the **Services** tab and click **My Activity** in the upper-right corner. A table of all your workflow executions, including their current status and key execution details. This allows you to quickly understand what ran, when it ran, and whether any action is required. * You can filter the table to display all workflow executions, only workflows that failed during execution in the Blink Portal or only workflows that completed when executing in the workflow * Next to the 'Date' field, you can select the to filter workflow executions according to a specified date and time *** ## Share Workflows to the Blink Portal In the [Workflow Overview](/docs/workflows/managing-workflows/workflow-overview-page) page, you can share and expose the selected workflow to the Blink Portal. 1. On the Workflow page, hover over the workflow you would like to expose to the Blink Portal and click on the "Overview" button. 2. Toggle the “Blink Portal” button to publish the selected workflow to the Blink Portal. Once enabled, the workflow becomes available for use in the portal. If you disable this toggle, the workflow will be removed from the Blink Portal and will no longer be available to users. *** ## Service Settings in the Blink Portal **Note**: These settings are only available to users with access to the workspace the selected service is part of. To access the Blink Portal's settings, click the menu and choose from the following options: 1. **Manage Portal Access**- Enter the email address of a user(s) or group(s) within your tenant to share the selected workflow in the Blink Portal. 2. **Navigate to the selected workflow**- Navigate directly to the workflow you have selected in the Blink Portal. 3. Navigate to the **workspace** where the selected workflow is located. # Dashboards For detailed guidance on Dashboards, see [Dashboards Documentation](/docs/blink-platform/dashboards/dashboards). In the **Dashboard** tab of the Blink Portal, you can access all dashboards you have shared to the Blink Portal * **Filter by workspace:** Narrow down dashboards based on the workspace they belong to. * **Filter by tags:** View dashboards according to the tags assigned to them. * **Search bar:** Quickly locate a specific dashboard by name or keyword. *** ## View Dashboard in the Blink Portal Select a 'Dashboard' to open it in the Blink Portal. In the top-right corner, you can configure the auto-refresh interval to control how often the dashboard updates and reflects the most recent data. By default, the dashboard refreshes **every 5 minutes**. Available refresh intervals: * Off (manual refresh only- ) * 5 seconds * 30 seconds * 1 minute * 5 minutes (default) * 15 minutes * 30 minutes * 1 hour Adjust the refresh setting based on how frequently you want the data to update. *** You can also select a **timeframe**, which acts as a **global filter** across the dashboard. This allows you to view only the data created within a specific time window—for example, all cases created in the last 7 days. **Note:** This filter applies only to widgets whose data source includes the `created_at` field. The available timeframes are: * **Today** * **Last 24 hours** *(default)* * **Last 7 days** * **Last 30 days** *** ## Dashboard Widget's Expanded View In the dashboards view mode, you can click on a widget to open an expanded view that displays the underlying raw data from the widget’s data source. Within this expanded view, you can also interact directly with elements of the visualization to further refine the data being displayed. For example, selecting a specific slice in a pie chart or an individual bar in a bar chart will filter the results to show only the raw records associated with that selected element. This allows you to quickly drill down into the data behind specific parts of the visualization directly from the dashboard. **Note:** When a widget is grouped by a user field (e.g., Case Manager or custom user fields), the expanded view shows the full underlying dataset *** ## Dashboard Settings in the Blink Portal **Note**: These settings are only available to users with access to the workspace the selected dashboard is part of. To access the Blink Portal's settings, click the menu and choose from the following options: 1. **Manage Portal Access**- Enter the email address of a user(s) or group(s) within your tenant to share the selected dashboard in the Blink Portal. 2. **Navigate to the selected workflow**- Navigate directly to the dashboard you have selected in the Blink Portal. 3. Navigate to the **workspace** where the selected dashboard is located. *** ## Sharing Dashboards to the Blink Portal To view a dashboard you created in the Blink Portal, you must first publish and share it. By default, the dashboard is shared only with you, but you can choose to share it with additional users or groups to provide them access. If you de-activate the dashboard, it will not show up in the Blink Portal Follow these steps to publish and share a dashboard you created in the Blink Portal: In the top-right corner of your dashboard, click the **Publish** button to start the sharing process. A pop-up will appear asking you to confirm that you want to share the dashboard. Click **Confirm** to proceed. After confirmation, you can enter the username(s) or group name(s) you want to share the dashboard with. By default, the dashboard is automatically shared with you and can now be found in the Blink Portal. *** ## Exporting Dashboards Once you find the dashboard you want, click on it to explore all its **widgets and data**. You can also **export the dashboard** by clicking the button in the top-right corner of the interface. For detailed guidance on Agents, visit the [Agent Documentation](/docs/agent-builder/agent-builder). In the **Agents** tab of the Blink Portal, you can access all agents that you been shared with you in the Blink Portal. * **Filter by workspace:** Narrow down dashboards based on the workspace they belong to. * **Search bar:** Quickly locate a specific dashboard by name or keyword. *** ## Agent Settings in the Blink Portal **Note**: These settings are only available to users with access to the workspace the selected dashboard is part of. To access the Blink Portal's settings, click the menu and choose from the following options: 1. **Manage Portal Access**- Enter the email address of a user(s) or group(s) within your tenant to share the selected agent in the Blink Portal. 2. **Navigate to the selected Agent**- Navigate directly to the agent you have selected in the Blink Portal. 3. Navigate to the **workspace** where the selected agent is located. *** # Blink App for Slack Source: https://docs.blinkops.com/docs/blink-platform/blink-portal/slack-app Connect workflows to Slack using the Blink app for direct messaging and channel-based automation. Blink is a platform that enables you to automate your daily work. A workflow is created using actions that integrate with a wide variety of cloud services. This application for Slack enables you to connect each Workflow you create in the [Blink Portal](/docs/blink-platform/blink-portal/blink-bot-for-slack) to your Slack workspace.