Loop FAQ

Loop is the orchestration layer of the ODW.ai suite. It wires ODW's individual agents (Vault, Desk, Recap, etc.) into automated, multi-step workflows that run entirely on your own infrastructure.

Here's how it works:

1. Visual builder: Drag-and-drop nodes to create workflows (no coding required)
2. Agent primitives: Use pre-built nodes for Vault (knowledge base), Desk (tasks), Recap (meeting intelligence)
3. Triggers: Workflows run on schedule, events, or manual triggers
4. Execution: Loop orchestrates the workflow, passing data between agents

Example workflow: "When a meeting ends → extract action items (Recap) → create tasks (Desk) → update knowledge base (Vault)"

The key difference from other workflow tools: agent-native, sovereign by design, model-agnostic. Loop understands ODW's agent primitives as first-class objects, and all data stays on your infrastructure.

Businesses face compounding challenges with AI agents:

• Siloed agents: Individual agents (knowledge base, meeting intelligence, task management) operate in isolation — no coordination
• Cloud dependency: Most workflow tools (Zapier, n8n) require sending data to their cloud — creating compliance exposure
• Vendor lock-in: Workflow tools are tied to specific AI models or cloud providers
• Complexity: Building multi-agent workflows requires deep technical expertise

Loop solves this by providing agent-native orchestration with sovereignty by design. You can coordinate ODW's agents into production workflows without cloud dependency or vendor lock-in.

Loop is designed for SMBs in regulated or data-residency-sensitive contexts:

• Legal: Law firms, legal tech — attorney-client privilege
• Healthcare: Hospitals, clinics, health tech — HIPAA-adjacent workflows
• Financial services: Banks, fintech, insurance — strict data sovereignty
• Government contractors: Defense, federal — strict data sovereignty
• Privacy-conscious enterprises: EU, APAC, LATAM regions — GDPR compliance
• Any business: That wants to automate AI agent workflows without cloud dependency

If you need to coordinate AI agents while keeping all data on your infrastructure, Loop is for you.

Zapier and n8n are general-purpose workflow tools. Loop is an agent-native orchestrator.

If you need to orchestrate AI agents with full data control, Loop is the better choice.

"Agent-native" means Loop understands ODW's agent primitives as first-class workflow objects:

• Vault documents: Loop can read/write documents, search, run RAG queries, manage tags
• Desk tasks: Loop can create/update tasks, manage projects, calendar operations
• Recap transcripts: Loop can ingest transcripts, extract action items, summarize, classify

Unlike generic workflow tools (which treat agents as opaque webhooks), Loop understands the semantic types of agent outputs. A "document" from Vault is a typed object, not just a JSON blob.

Loop is both:

• Standalone: You can use Loop by itself for workflow automation
• Suite-integrated: Loop is the orchestration layer of the ODW.ai suite and integrates with other modules:
  • Vault: Knowledge base (documents, RAG, tags)
  • Desk: Workspace (tasks, projects, calendar)
  • Recap: Meeting intelligence (transcripts, action items, summaries)
  • Shield: Governance (audit logging, compliance reporting)

The suite integration is what makes Loop powerful — it can coordinate ODW's agents into production workflows with full semantic understanding.

"Sovereign by design" means all workflow data stays on your infrastructure:

• Zero data egress: No data leaves your infrastructure (unless you explicitly configure it)
• Local execution: All workflow execution happens on your hardware
• No telemetry: No usage data sent to ODW.ai (unless you opt in)
• Air-gapped: Loop can run in air-gapped environments (no internet access required)

This is critical for regulated industries. You can't claim data sovereignty if your workflow tool is sending data to a cloud vendor.

For deployment: Yes. Loop is self-hosted, so you need someone who can manage Docker/Kubernetes, configure networking, and monitor infrastructure.

For workflow authoring: No. Loop provides a visual drag-and-drop builder — non-engineers can compose workflows in under 30 minutes.

For advanced logic: Yes. Loop provides a code node (Python/TypeScript) for custom logic — engineers can drop into code without leaving the platform.

It depends.

• If you need AI agent orchestration: Yes. Loop is purpose-built for coordinating AI agents (Vault, Desk, Recap, etc.)
• If you need general-purpose automation: Maybe. Loop can integrate with external services via webhooks, but it's not as broad as Zapier/n8n for non-AI use cases

Loop is not trying to replace Zapier/n8n for general-purpose automation. It's the orchestrator for ODW's sovereign agent suite.

If you're already using ODW's agents and need to coordinate them, Loop is the right choice. If you need to automate non-AI workflows (e.g., "when a form is submitted, send an email"), Zapier/n8n may be better.

Loop provides a visual drag-and-drop builder:

1. Node library: Browse pre-built nodes (Vault, Desk, Recap, logic, code)
2. Drag-and-drop: Drag nodes onto the canvas
3. Connect nodes: Draw edges between nodes to define data flow
4. Configure nodes: Set parameters, conditions, and error handling
5. Test: Run the workflow in test mode
6. Deploy: Activate the workflow for production use

Target: Non-engineers can build production workflows in under 30 minutes.

Loop supports multiple node types:

• Agent nodes: Vault (read/write documents, search, RAG), Desk (tasks, projects, calendar), Recap (transcripts, action items, summaries)
• Logic nodes: Conditional branching, loops, parallel execution, error handling
• Code nodes: Python and TypeScript for custom logic
• Trigger nodes: Scheduled (cron), event-driven (webhooks, file-watchers), manual
• Integration nodes: HTTP requests, database queries, file operations

The node library is extensible — you can create custom nodes for your specific use cases.

Yes. Loop provides conditional branching:

• If/else: Branch based on conditions (e.g., "if sentiment is negative, escalate to manager")
• Switch: Multi-way branching based on values
• Filters: Filter data based on criteria
• Loops: Iterate over lists (e.g., "for each action item, create a task")

Conditional logic enables complex workflows with dynamic behavior.

Yes. Loop provides a code node:

• Languages: Python and TypeScript
• Use cases: Custom data transformations, complex logic, API integrations
• Sandboxed: Code runs in a secure sandbox
• Access to workflow context: Code can read/write workflow variables

Code nodes are useful when visual nodes aren't sufficient — engineers can drop into code without leaving the platform.

Yes. Loop provides git-backed version control:

• Automatic commits: Every workflow change is committed to git
• Branching: Create branches for experimental workflows
• Rollback: Revert to previous versions
• Collaboration: Multiple users can work on workflows (with conflict resolution)

Version control ensures you can track changes, collaborate safely, and roll back if something breaks.

Yes. Loop provides pre-built workflow templates:

• Meeting → Action Items → Tasks: Extract action items from meeting transcripts, create tasks in Desk
• Document → Knowledge Base: Ingest documents, extract key information, update Vault
• Customer Inquiry → Response: Route customer inquiries to the right agent, generate responses
• Compliance Check: Audit workflows for regulatory compliance

Templates are a starting point — customize them for your specific use cases.

Yes. Loop provides test mode:

• Dry run: Execute the workflow with sample data
• Step-through: Execute the workflow one node at a time
• Debug: Inspect intermediate outputs at each node
• Logs: View execution logs for troubleshooting

Test mode ensures you can validate workflows before deploying to production.

Yes. Loop provides sub-workflows:

• Modular design: Create reusable workflow components
• Parameters: Pass inputs to sub-workflows
• Return values: Sub-workflows can return outputs
• Library: Build a library of reusable components

Sub-workflows enable modular, maintainable workflow design — build once, reuse everywhere.

Loop competes on agent-native orchestration + sovereignty + model-agnostic. If you need to coordinate AI agents with full data control, Loop is the best option.

Loop provides a low-code surface:

• Visual builder: Drag-and-drop nodes, no coding required
• Pre-built nodes: Common operations are one-click
• Templates: Start from pre-built workflow templates
• Type-safe: The system prevents invalid connections (e.g., can't connect a "document" to a "number" field)

Target: Non-engineers can build production workflows in under 30 minutes.

Loop provides reliability features:

• Retry logic: Automatically retry failed nodes with configurable backoff
• Timeout controls: Set timeouts per node to prevent hangs
• Circuit breakers: Stop workflows if downstream services are unavailable
• Error handling: Define error handlers for each node
• Execution history: Full input/output capture for every run

Target: ≥98% workflow execution success rate.

Yes. Loop supports complex workflows:

• Parallel execution: Run multiple branches simultaneously
• Loops: Iterate over lists (e.g., "for each document, extract key information")
• Conditional branching: Dynamic behavior based on data
• Sub-workflows: Modular, reusable components
• State management: Track state across workflow runs

Loop is designed for production-grade workflows — not just simple automations.

Yes. Loop provides a metrics dashboard:

• Success rate: % of successful workflow runs
• Latency: Time to complete workflows
• Throughput: Number of workflow runs per hour/day
• Error rates: Track failures by node
• Resource usage: CPU, memory, disk usage

You can also export metrics to external monitoring tools (Prometheus, Grafana, Datadog) via standard protocols.

Yes. Loop provides error alerting:

• Webhook: Send alerts to your monitoring system
• Email: Send email alerts
• Slack: Send alerts to Slack channels
• Custom: Integrate with your alerting system via API

Alerting ensures you can respond to failures quickly — before they impact business operations.

Yes. Loop supports high-volume execution:

• Scalable infrastructure: Kubernetes-based deployment scales horizontally
• Priority queues: Prioritize critical workflows (Scale tier)
• Parallel execution: Run multiple workflows simultaneously
• Batch processing: Process large datasets efficiently

For high-volume use cases (10,000+ workflow runs/day), we recommend:

• Kubernetes: For auto-scaling and high availability
• Managed database: RDS, Cloud SQL, or Azure SQL
• Load balancer: Distribute traffic across replicas

It depends.

• If you're orchestrating AI agents: Yes. Loop is purpose-built for coordinating AI agents (Vault, Desk, Recap, etc.)
• If you're doing general-purpose automation: Maybe. Loop can integrate with external services via webhooks, but it's not as broad as Zapier/n8n for non-AI use cases

Loop is not trying to replace Zapier/n8n for general-purpose automation. It's the orchestrator for ODW's sovereign agent suite.

If you're already using ODW's agents and need to coordinate them, Loop is the right choice.

Loop supports multiple trigger types:

• Scheduled: Cron-style scheduling (e.g., "every day at 9am", "every hour")
• Event-driven: Webhooks, file-watchers, ODW agent events
• Manual: UI button, API call
• Chained: Triggered by another workflow

You can combine triggers (e.g., "run every hour OR when a file is uploaded").

Yes. Loop provides cron-style scheduling:

• Simple schedules: "Every hour", "Every day at 9am", "Every Monday"
• Complex schedules: Cron expressions (e.g., "0 9 * * 1-5" = 9am on weekdays)
• Timezone-aware: Schedule in your local timezone
• Missed runs: Configure behavior for missed runs (skip, run once, run all)

Scheduled workflows are useful for recurring tasks (e.g., "sync data every hour", "generate report every day").

Yes. Loop provides event-driven triggers:

• Webhooks: Trigger workflows via HTTP requests
• File-watchers: Trigger workflows when files are created/modified
• ODW agent events: Trigger workflows when agents complete tasks (e.g., "when a meeting ends")
• Database events: Trigger workflows when database records change

Event-driven workflows are useful for reactive automation (e.g., "when a customer submits a form, process the data").

Yes. Loop provides manual triggers:

• UI button: Click a button in the Loop console to run a workflow
• API call: Trigger workflows via REST API
• CLI: Trigger workflows via command-line interface

Manual triggers are useful for on-demand tasks (e.g., "generate report now", "sync data on demand").

Loop provides error handling:

• Retry logic: Automatically retry failed nodes with configurable backoff
• Error handlers: Define custom error handlers for each node
• Fallback workflows: Run a fallback workflow if the main workflow fails
• Alerting: Get notified of failures (webhook, email, Slack)
• Execution history: Inspect failed runs to diagnose issues

Target: Mean time to recover from workflow failure ≤2 minutes.

Yes. Loop provides workflow controls:

• Pause: Pause a running workflow (resumable)
• Stop: Stop a running workflow (not resumable)
• Cancel: Cancel a scheduled workflow
• Disable: Disable a workflow (prevents future runs)

These controls are useful for troubleshooting, maintenance, or stopping runaway workflows.

Yes. Loop supports parallel execution:

• Parallel branches: Run multiple branches of a workflow simultaneously
• Parallel workflows: Run multiple workflows simultaneously
• Resource limits: Configure concurrency limits to prevent resource exhaustion

Parallel execution is useful for performance (e.g., "process 100 documents in parallel instead of sequentially").

Yes. Loop provides wait nodes:

• Time-based wait: Wait for a specific duration (e.g., "wait 5 minutes")
• Event-based wait: Wait for an external event (e.g., "wait for webhook callback")
• Timeout: Configure timeouts for waits

Wait nodes are useful for workflows that need to pause and resume (e.g., "send approval request, wait for approval, continue workflow").

Yes. Loop is built with security best practices:

• Self-hosted: All workflow data stays on your infrastructure
• Encryption: AES-256 at rest, TLS 1.3 in transit
• Access control: RBAC, SSO (via Shield integration)
• Audit logging: Tamper-evident logs of all workflow executions (via Shield)
• Open source: Code is auditable — you can verify there are no backdoors or data exfiltration

Loop is designed for regulated industries. If you can use Loop, you can pass a compliance audit.

No. Loop is self-hosted on your infrastructure. ODW.ai has zero access to your workflow data.

Unlike cloud-based workflow tools (Zapier, n8n cloud), Loop doesn't send workflow data to a third party. Everything stays on your servers.

This is critical for regulated industries. You can't claim data sovereignty if your workflow tool is sending data to a cloud vendor.

Yes. Loop supports air-gapped deployment (no internet access):

• Offline installation: Install Loop without internet access
• Local models: All AI models run on your device — no API calls to external services
• No external dependencies: Loop doesn't require internet access for core functionality

Air-gapped deployment is common for government contractors, military, and high-security environments.

Yes. Loop provides role-based access control (via Shield integration):

• Admin: Full access — create, edit, delete workflows, manage users
• Developer: Create and edit workflows, but can't delete or manage users
• Operator: Run workflows, view execution history, but can't edit workflows
• Viewer: Read-only access

You can also set per-workflow permissions (e.g., only specific users can run sensitive workflows).

Yes. Loop provides audit logging (via Shield integration):

• Who: Which user ran the workflow
• What: Which workflow was run
• When: Timestamp
• Input/Output: Full input/output capture for every run

All audit logs are tamper-evident and can be exported for compliance purposes.

Loop provides access control and alerting:

• Access control: Role-based access prevents unauthorized workflow execution
• Alerting: Get notified of unauthorized access attempts
• Audit trail: All access is logged (including blocked attempts)
• Investigation: Use audit logs to investigate incidents

For critical incidents, you can generate a full audit report for regulators or legal counsel.

Yes. Loop's core is open source:

• Transparent: All code is publicly available on GitHub
• Auditable: You (or your security team) can inspect the code for vulnerabilities, backdoors, or data exfiltration
• Verifiable: You can verify that Loop does what it claims — no hidden telemetry, no data sent to third parties

This is critical for sovereignty-focused organizations. You should be able to verify what your workflow tools are doing.

Loop is HIPAA-compatible for healthcare workflows:

• On-premise processing: Workflow data stays on your infrastructure
• Encryption: AES-256 encryption for local storage
• Access control: Password protection, role-based access
• Audit logging: Tamper-evident logs of all workflow executions

Loop helps you meet the technical safeguards required by HIPAA. You still need to address administrative and physical safeguards separately.

Loop is model-agnostic — it supports a wide range of models:

• Local models: Llama 3, Mistral, Gemma, Qwen (via Ollama, vLLM, llama.cpp)
• API-based models: OpenAI (GPT-4o, GPT-4o-mini), Anthropic (Claude 3.5 Sonnet), Google (Gemini 1.5 Pro), Mistral API
• Custom: Any model that exposes an OpenAI-compatible API

You can switch models at any time — no code changes required.

Yes. Loop supports local models via:

• Ollama: Easiest way to run local models. Supports Llama 3, Mistral, Gemma, etc.
• vLLM: High-performance inference server for production workloads
• llama.cpp: Lightweight, CPU-friendly inference (good for edge devices)

Local models run on your own hardware — no data leaves your infrastructure. Full sovereignty.

Yes. Loop supports API-based models:

• OpenAI: GPT-4o, GPT-4o-mini
• Anthropic: Claude 3.5 Sonnet, Claude 3 Opus
• Google: Gemini 1.5 Pro
• Mistral: Mistral Large, Mistral Medium
• Custom: Any model that exposes an OpenAI-compatible API

API-based models are useful when you need frontier capabilities (e.g., complex reasoning, long context windows) that local models can't match yet.

Choosing a model depends on your priorities:

Recommendation:

• Maximum sovereignty: Use Llama 3 8B or 70B (local, free)
• Maximum quality: Use GPT-4o or Claude 3.5 Sonnet (API, paid)
• Balanced: Use Llama 3 8B for routine tasks, GPT-4o-mini for complex reasoning

Yes. Loop is model-agnostic — you can switch models at any time:

• No code changes: Just update the model configuration in the admin console
• Per-task: Use different models for different tasks (e.g., small model for data extraction, large model for complex reasoning)

This future-proofs your investment — when better models are released, you can adopt them immediately without re-architecting your system.

Not in Loop v1.0. Loop uses existing models — it doesn't support fine-tuning.

However, you can:

• Use prompt engineering: Customize prompts to guide the model's behavior
• Use Vault: Ground AI in your knowledge base
• Fine-tune externally: Fine-tune a model outside of Loop (using tools like Hugging Face Transformers), then use the fine-tuned model in Loop via a custom endpoint

Fine-tuning support is planned for v2.0 (Q2 2027).

No. Loop is an orchestrator, not a decision-maker.

Loop executes workflows as defined — it doesn't make decisions on its own. If you want human oversight, you can add approval nodes to workflows (e.g., "wait for human approval before sending email").

This is a design choice — Loop gives you full control over when and how humans are involved in workflows.

Loop offers three deployment options:

1. Docker Compose: Easiest. One command (docker-compose up) and you're running. Best for development and small deployments.
2. Kubernetes (Helm): Production-ready. Helm chart provided. Best for large deployments, high availability, auto-scaling.
3. Bare metal: For advanced users. Install directly on Linux servers. Maximum control, but requires more setup.

For most customers, Docker Compose is the fastest path. For production, we recommend Kubernetes.

Setup time depends on your deployment:

• Docker Compose: 30 minutes. Pull images, configure environment variables, run docker-compose up.
• Kubernetes: 2-4 hours. Deploy Helm chart, configure ingress, set up storage, test.
• Bare metal: 1-2 days. Install dependencies, configure services, test.

After deployment, you need to:

• Configure your first workflow (30 minutes)
• Set up integrations (Vault, Desk, Recap)
• Test the workflow

Target: ≤45 minutes from deployment to first workflow running.

For deployment: Yes. Loop is self-hosted, so you need someone who can manage Docker/Kubernetes, configure networking, and monitor infrastructure.

For workflow authoring: No. Loop provides a visual drag-and-drop builder — non-engineers can compose workflows without writing code.

For developers: Loop provides a REST API and SDKs for custom integrations.

Loop's requirements depend on your deployment:

If you use API-based models (OpenAI, Anthropic), you don't need a GPU. If you use local models, GPU is strongly recommended.

Yes. Loop can be deployed on any cloud provider:

• AWS: Use EC2 (for Docker Compose) or EKS (for Kubernetes)
• GCP: Use GCE (for Docker Compose) or GKE (for Kubernetes)
• Azure: Use VMs (for Docker Compose) or AKS (for Kubernetes)

We provide deployment guides for each cloud provider. For production, we recommend Kubernetes with managed databases.

Yes. Loop supports workflow migration:

• Import workflows: Import workflows from Zapier, n8n, etc. (via JSON/YAML)
• Migration guides: Step-by-step guides for common workflow tools
• Manual rebuild: For complex workflows, you may need to rebuild them in Loop's visual builder

Migration typically takes 1-2 days depending on workflow complexity.

Yes. Loop includes a sandbox mode:

• Test environment: Deploy Loop in a test environment with sample data
• Experiment: Test different workflows, integrations, and configurations
• Evaluate: Measure performance, reliability, and compliance before going live

We recommend spending 1-2 days testing in sandbox mode before deploying to production.

For Docker Compose: Pull the new image, restart containers.

For Kubernetes: Update the Helm chart, rolling update.

For bare metal: Follow the upgrade guide in the documentation.

Total update time: <10 minutes (for Docker/Kubernetes).

Loop pricing is based on features and deployment:

Additional costs:

• API costs: If you use API-based models (OpenAI, Anthropic), you pay the API provider directly
• Infrastructure: You pay for your own servers/cloud (if self-hosting)

It depends.

• Zapier: $20-$500+/month (depending on tasks and features)
• n8n: Free (self-hosted) or $20-$200+/month (cloud)
• Loop Core: Free (self-hosted)
• Loop Scale: Usage-based (typically $50-$500/month for SMBs)

For self-hosted deployments, Loop Core is free — comparable to n8n self-hosted, and cheaper than Zapier.

However, Loop requires you to manage your own infrastructure. If you factor in infrastructure costs, the total cost of ownership may be higher.

For most regulated SMBs, Loop is cheaper and more compliant than cloud-based alternatives.

No hidden costs. The total cost of ownership includes:

• Loop subscription: Monthly fee based on tier (or free for Core)
• API costs: If you use API-based models (OpenAI, Anthropic), you pay the API provider directly
• Infrastructure: You pay for your own servers/cloud (if self-hosting)

That's it. No setup fees, no surprise charges, no per-workflow fees.

We accept:

• Credit/debit cards: Visa, Mastercard, American Express (via Stripe)
• Bank transfer: For annual subscriptions or enterprise customers
• Cryptocurrency: Bitcoin, Ethereum, USDC (for privacy-conscious customers)

Invoicing is available for annual subscriptions. Contact us for details.

Yes. We offer a 30-day money-back guarantee for paid tiers. If you're not satisfied within the first 30 days, contact us for a full refund — no questions asked.

After 30 days, you can cancel anytime. You'll continue to have access until the end of your billing period, but no refund is provided for partial months.

The Core tier is free, so there's no refund needed.

Yes. Loop is part of the ODW.ai suite. You can:

• Purchase Loop standalone: Use Loop by itself
• Purchase the full suite: Get Desk, Voice, Vault, Loop, Shield, and other modules at a discounted price

The suite bundle includes Loop at a 20-30% discount compared to purchasing separately. And all modules integrate natively — Loop orchestrates Vault, Desk, Recap, and other agents.

Neither (for Core tier). Loop Core is free with unlimited workflows and executions.

For Scale tier, pricing is usage-based — you pay for the resources you consume (CPU, memory, storage).

The only variable cost is API costs (if you use API-based models). You pay the API provider directly for token usage.

Loop can handle unlimited workflows:

• No workflow limit: Create as many as you want
• No execution limit: Run as many executions as you want
• Scalable infrastructure: Kubernetes-based deployment scales horizontally

For high-volume use cases (10,000+ workflow runs/day), we recommend:

• Kubernetes: For auto-scaling and high availability
• Managed database: RDS, Cloud SQL, or Azure SQL
• Load balancer: Distribute traffic across replicas

Loop supports unlimited users:

• Core tier: Unlimited users
• Scale tier: Unlimited users
• Enterprise tier: Unlimited users

Loop scales horizontally — add more nodes to handle more concurrent users. Typical deployments support 50-200 concurrent users per node.

If Loop goes down, workflow execution is unavailable, but your data is safe:

• Data storage: All data is stored in your database (SQLite or PostgreSQL) — not lost
• Recovery: Restart Loop, and it reconnects to your database
• High availability: For production, deploy Loop with multiple replicas (Kubernetes)

For high-availability deployments, we recommend:

• Kubernetes: 3+ replicas across availability zones
• Managed database: RDS, Cloud SQL, or Azure SQL (99.9% uptime SLA)
• Load balancer: Distribute traffic across replicas

Loop includes a monitoring dashboard:

• System health: CPU, memory, disk, network usage
• Workflow metrics: Number of workflows, executions, success rates
• Model metrics: API costs, token usage, model latency
• Error tracking: Track failures by workflow and node

You can also export metrics to external monitoring tools (Prometheus, Grafana, Datadog) via standard protocols.

Loop data is stored in SQLite (Core) or PostgreSQL (Scale). Back up using standard database tools:

• SQLite: Copy the database file (simple, but requires downtime)
• PostgreSQL: Use pg_dump or WAL archiving for automated backups
• Off-site storage: Store backups in a different location (e.g., S3, GCS, off-site server)
• Test restores: Periodically test restoring from backups to ensure they work

Loop provides backup guides and scripts for common deployment modes (Docker, Kubernetes, on-premises).

Yes. Loop supports multi-tenancy:

• Multiple workspaces: Create separate workspaces for each team or department
• Isolation: Each workspace has its own workflows, data, and settings
• Shared resources: Share workflows across workspaces (if needed)

This is useful for enterprises with multiple business units, or agencies managing multiple clients.

Loop is designed to be intuitive, but we provide training resources:

• Documentation: Comprehensive user guides for admins and workflow authors
• Video tutorials: Step-by-step walkthroughs of key features
• Onboarding session: For paid customers, we offer a 2-hour onboarding session (remote)
• Support: Priority support for Scale and Enterprise customers

Most teams are productive within 1-2 days of training. The visual builder is particularly intuitive — no technical skills required for workflow authoring.

Loop integrates natively with all ODW.ai products:

• Vault: Knowledge base (documents, RAG, tags)
• Desk: Workspace (tasks, projects, calendar)
• Recap: Meeting intelligence (transcripts, action items, summaries)
• Shield: Governance (audit logging, compliance reporting)

If you're using the ODW.ai suite, Loop integration is automatic — no separate configuration required.

Yes. Loop provides a REST API for programmatic access:

• Workflow management: Create, update, delete workflows via API
• Execution: Trigger workflows via API
• Execution history: Retrieve execution logs via API
• Webhooks: Get notified when workflows complete, fail, etc.

The API is fully documented (OpenAPI/Swagger) and supports authentication via API keys or OAuth 2.0.

Yes. Loop supports external integrations:

• HTTP requests: Call any REST API
• Database queries: Connect to PostgreSQL, MySQL, etc.
• File operations: Read/write files, watch directories
• Webhooks: Send/receive webhooks
• Premium connectors: SAP, Salesforce, ServiceNow, custom ERP (Enterprise tier)

External integrations enable Loop to connect with your existing systems and data sources.

Yes. Loop can be used with existing AI tools:

• LangChain: Use Loop as an orchestration layer in LangChain pipelines
• LlamaIndex: Use Loop as an orchestration layer in LlamaIndex pipelines
• Custom RAG: Use Loop's API in your custom pipelines

Loop is designed to be an orchestration layer — it coordinates AI agents, and you can use any AI tool for specific tasks.

Yes. Loop supports workflow import/export:

• Export: Export workflows as JSON or YAML
• Import: Import workflows from JSON or YAML
• Version control: Workflows are git-backed — automatic versioning
• Sharing: Share workflows across deployments

Import/export is useful for backup, migration, and collaboration.

Yes. Loop supports database integrations:

• PostgreSQL: Native support
• MySQL: Native support
• SQLite: Native support (Core tier)
• Custom: Use code nodes (Python/TypeScript) to connect to other databases

Database integrations enable Loop to read/write data from your existing databases.

Yes. Loop supports file storage integrations:

• Local filesystem: Read/write files on your server
• S3-compatible: AWS S3, MinIO, etc.
• Google Cloud Storage: GCS
• Azure Blob Storage: Azure Blob

File storage integrations enable Loop to read/write files from your existing storage systems.

Loop is powerful, but it has limitations in v1.0:

• No managed SaaS: ODW.ai will not operate Loop in the cloud for customers (self-hosted only)
• No mobile app: Mobile monitoring only (post-v1.0), no mobile workflow authoring
• No real-time collaboration: No multiplayer canvas for collaborative workflow editing
• No natural-language workflow generation: Can't say "build me a workflow that..." (planned for v1.1)
• No workflow marketplace: No community template sharing in v1.0 (internal templates only)
• No cross-organization federation: Can't share workflows across organizations

Yes. Natural-language workflow generation is planned for v1.1 (Q4 2026):

• Describe workflows: "Build me a workflow that extracts action items from meeting transcripts and creates tasks"
• AI generates: Loop generates the workflow automatically
• Human reviews: You review and approve the generated workflow

This is a high-priority feature for non-technical users who want to build workflows without using the visual builder.

Yes. A community template marketplace is planned for v1.1 (Q4 2026):

• Share templates: Share your workflows with the community
• Browse templates: Browse and import community workflows
• Rate and review: Rate and review community workflows

This will enable the community to build a library of reusable workflow templates.

Key milestones:

• v1.0 (Q3 2026): MVP launch. Visual builder, agent-native orchestration, self-hosted, model-agnostic.
• v1.1 (Q4 2026): Natural-language workflow generation, community template marketplace, advanced monitoring.
• v1.2 (Q1 2027): Mobile workflow authoring, real-time collaboration, advanced error handling.
• v2.0 (Q2 2027): Model fine-tuning, cross-organization federation, white-label/OEM licensing.

Roadmap is subject to change based on customer feedback. Contact us for the latest roadmap or to request features.

Loop is not the right fit if:

• You need managed SaaS: If you don't want to manage your own infrastructure, Loop is not for you (self-hosted only)
• You need general-purpose automation: If you need to automate non-AI workflows (e.g., "when a form is submitted, send an email"), Zapier/n8n may be better
• You need mobile workflow authoring: Loop is web-responsive only in v1.0. If you need native mobile apps, wait for v1.2
• You need real-time collaboration: Loop doesn't support multiplayer canvas in v1.0. If you need collaborative workflow editing, wait for v1.2

No. No system can guarantee 100% reliability — failures happen (network issues, downstream service outages, etc.).

Loop helps you maximize reliability through:

• Retry logic: Automatically retry failed nodes
• Error handling: Define custom error handlers
• Monitoring: Track success rates, latency, errors
• Alerting: Get notified of failures

Target: ≥98% workflow execution success rate. But results vary by use case and infrastructure quality.

No. Loop is designed to augment your development team, not replace it.

Loop automates workflow orchestration, freeing your developers to focus on:

• Custom logic: Building complex business logic that can't be expressed visually
• Integration: Building custom integrations with legacy systems
• Optimization: Optimizing performance, security, and compliance

Loop makes your development team more efficient — it doesn't replace the human element that's critical to good software.

Three paths:

1. Free Core tier: Download Loop and deploy it yourself. No credit card required. Try it with your workflows and see if it works for your use case.
2. Demo: Book a demo with our team. We'll walk you through Loop, answer your questions, and help you evaluate if it's right for your business.
3. Contact sales: For Scale or Enterprise tiers, contact our sales team for a tailored quote.