Skip to content
Back to search

atlasclaw

AtlasClaw is an enterprise agent framework supporting mutliple users and multi system integration.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/CloudChef/atlasclaw with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/CloudChef/atlasclaw'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/cloudchef--atlasclaw/badge.svg)](/listings/cloudchef--atlasclaw)

HTML

<a href="/listings/cloudchef--atlasclaw"><img src="/api/listings/cloudchef--atlasclaw/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Requirements

- Python 3.11+ - A virtual environment is recommended - Access to an LLM provider and target enterprise systems for end-to-end integration

Install Dependencies

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

For development and test execution, install the development manifest instead; it includes all runtime dependencies plus the test runner:

pip install -r requirements-dev.txt

Configure Environment

AtlasClaw uses `atlasclaw.json` for configuration. Create a configuration file in the project root:

{
  "providers_root": "../atlasclaw-providers/providers",
  "model": {
    "primary": "kimi/kimi-k2.5",
    "temperature": 0.7,
    "providers": {
      "kimi": {
        "base_url": "${ANTHROPIC_BASE_URL}",
        "api_key": "${ANTHROPIC_API_KEY}",
        "api_type": "anthropic"
      }
    }
  }
}

The example above assumes a sibling `atlasclaw-providers` repository. The schema default for `providers_root` remains `../providers`.

Configuration options:

- `providers_root` - Root directory for provider packages, resolved relative to `atlasclaw.json` (schema default: `../providers`) - Provider skills discovered under `providers_root` are registered as `provider:skill` to avoid name collisions - `model.primary` - Primary model in format `provider/model-name` - `model.providers` - Provider configurations with `base_url`, `api_key`, and `api_type` - `api_type` - API type: `openai` (default) or `anthropic`

Environment variables are expanded from `${VAR_NAME}` format. Set them before starting:

# For Kimi (Anthropic-compatible API)
export ANTHROPIC_BASE_URL="https://api.moonshot.cn/anthropic"
export ANTHROPIC_API_KEY="your-api-key"

# For Doubao (OpenAI-compatible API)
export DOUBAO_BASE_URL="https://ark.cn-beijing.volces.com/api/v3"
export DOUBAO_API_KEY="your-api-key"

Run Tests

# Run all tests
pytest tests/atlasclaw -q

# Run LLM integration tests (requires API credentials)
export ANTHROPIC_BASE_URL="https://api.moonshot.cn/anthropic"
export ANTHROPIC_API_KEY="your-api-key"
pytest tests/atlasclaw/test_agent_integration.py -v -m llm

# Run e2e tests (requires running service)
pytest tests/atlasclaw/test_e2e_api.py -v -m e2e

Start the Service

Start the backend API server:

uvicorn app.atlasclaw.main:app --reload --host 0.0.0.0 --port 8000

The API will be available at `http://127.0.0.1:8000`.

Access the Web UI

Once the service is running, open your browser and navigate to:

http://127.0.0.1:8000/

The Web UI provides: - Chat interface powered by DeepChat - Real-time streaming responses via SSE - Multi-language support (Chinese / English) - Session management with conversation history

Frontend Development

The frontend is located in `app/frontend/` and supports two deployment modes:

**Open Source Mode** (default): - Source files are served directly without bundling - No build step required - Edit files in `app/frontend/scripts/` and refresh browser

**Enterprise Mode**:

cd app/frontend
npm install
npm run build

- Produces minified `dist/app.min.js` - Update `index.html` to reference the bundled file

**Run Frontend Tests**:

cd app/frontend
npm test

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 282 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. > [!NOTE]
  2. > This repository contains the AtlasClaw core implementation, including the agent runtime, API layer, channel adapters, provider registry, skills, tools, and session/memory management,see [atlasclaw.ai](https://atlasclaw.ai/).
  3. >
  4. > Concrete providers are not implemented in this repository. AtlasClaw loads
  5. > provider packages from `providers_root`. In a sibling-repository layout, a
  6. > common value is `../atlasclaw-providers/providers`.
  7. # AtlasClaw
  8. ![AtlasClaw logo](docs/images/atlasclaw-icon.png)
  9. AtlasClaw is an enterprise agent framework that lets employees interact with multiple enterprise systems through one conversational AI interface. Instead of switching between separate consoles, dashboards, and approval portals, users can use natural language to trigger workflows, query operational data, and complete cross-system tasks from a single entry point.
  10. ## Background
  11. Enterprise software teams often need to work across CRM, ITSM, Monitoring, HR, Finance, OA and other internal systems. The challenge is not only system fragmentation, but also the mismatch between data models, workflow boundaries, authorization models, and user experience across those systems.
  12. AtlasClaw is designed around two practical developer questions:
  13. - How do you provide one unified AI Agent experience on top of the systems an enterprise already has?
  14. - How do you let enterprise software developers add AI Agent capabilities to their own systems quickly, without rebuilding agent infrastructure from scratch?
  15. AtlasClaw addresses those problems with a developer-oriented agent framework:
  16. - A unified conversational layer for cross-system workflows and operations
  17. - A pluggable provider model that lets developers expose system capabilities to the agent quickly
  18. - Strict permission inheritance so every action runs under the authenticated user's real access rights
  19. - Multi-channel access through web UI, embedded panels, chat platforms, and programmatic webhooks
  20. The framework is built to help teams add agent capabilities to existing enterprise software without weakening governance. AtlasClaw does not bypass RBAC, does not escalate privileges, and keeps platform-specific authorization and auditing where they already belong.
  21. ## Key Capabilities
  22. - LLM-driven Skills model instead of hard-coded traditional workflows
  23. - Skills define business scenarios, decision boundaries, and how the agent interacts with external systems
  24. - A cross-system agent brain for analysis, judgment, coordination, and execution across enterprise software
  25. - Provider-based integration model that lets developers add new system capabilities quickly
  26. - Thin-core architecture that keeps platform-specific logic in Providers and reusable agent logic in the core
  27. - Embeddable agent foundation for enterprise application developers
  28. - Context-aware floating assistant that follows Enterprise System navigation and binds the current page
  29. object to the appropriate Provider Skill
  30. - Core-matched, Provider-defined dynamic Context routes and object actions without
  31. page-specific business mappings in AtlasClaw Core
  32. - API-first interaction model with interactive APIs, WebSocket streaming, and webhook entry points
  33. - Flexible LLM backend support through external model providers
  34. ## Deployment Modes
  35. AtlasClaw supports two practical usage modes for enterprise software teams.
  36. ### Embedded Agent Mode
  37. AtlasClaw can be embedded into an existing enterprise system as a module inside that system. In this mode, the AI Agent becomes part of the product itself, serving that system's own users, data, and business scenarios.
  38. - Embedded as an in-product AI module
  39. - Provides two independent embedded surfaces that can be deployed together:
  40. a full menu UI and a compact floating UI
  41. - Uses the same Enterprise System Cookie authentication context for both
  42. surfaces, so they share the signed-in user's existing system access and
  43. upstream permissions
  44. - Keeps menu integration minimal: the Enterprise System only adds a menu entry and
  45. embeds the Agent with `embedded=1&surface=menu`
  46. - Adds a generic page bridge for floating mode: the Enterprise System manages
  47. the launcher/iframe and reports normalized page paths with a nonce and a
  48. monotonically increasing generation
  49. - Lets the two surfaces share a bootstrap-validated active Chat Session without
  50. turning one surface into the other
  51. - Re-resolves Context when the Enterprise System page changes, so the assistant
  52. follows the current business object in the floating UI instead of keeping
  53. stale page state
  54. - Lets Core match Provider-owned route manifests, while Provider resolvers load
  55. a minimal object projection and present state-aware actions
  56. - Supports both user-facing interaction interfaces and agent-style automation
  57. - Uses Skills to define scenarios and system-specific actions inside the existing system
  58. - Fits teams that want to add AI Agent capability to an existing enterprise product quickly
  59. The formal integration component is the configured **HostApp Provider** inside
  60. AtlasClaw. It maps Enterprise System pages to business objects, Domain Skills,
  61. and state-aware actions without requiring a new service in the Enterprise
  62. System. See [Embedded Integration](docs/EMBED-INTEGRATION.md) for the Cookie,
  63. surface, Context, and message contracts.
  64. ### Standalone Agent Mode
  65. AtlasClaw can also run as an independent enterprise AI Agent system that connects multiple existing systems together. In this mode, it acts as a unified AI layer above those systems rather than belonging to only one of them.
  66. - Runs as an independent AI Agent platform for the enterprise
  67. - Connects and coordinates multiple systems through Providers
  68. - Builds a shared cross-system brain for analysis, judgment, coordination, and execution
  69. - Fits teams that want one unified AI Agent entry point across the enterprise
  70. ## Architecture
  71. AtlasClaw is organized around a thin core plus rich providers.
  72. - Access channels support both embedded in-system experiences and standalone enterprise entry points
  73. - AtlasClaw Core hosts the API layer, session/config services, and the agent engine
  74. - LLM services are external and replaceable through configuration
  75. - Providers encapsulate authentication, skills, and scripts for each connected enterprise platform
  76. - Enterprise systems remain the source of truth for authorization and auditing
  77. ### Overall Architecture
  78. ![AtlasClaw overall architecture](docs/images/architecture/v4-01-overall-architecture.png)
  79. At a high level, requests enter through one of the supported channels, pass through the AtlasClaw Core, and are executed against enterprise systems through Providers. Embedded mode exposes two independent entry points inside an existing Enterprise System: a full menu UI for ordinary conversations and a compact floating UI for page-scoped assistance. Both receive the same Enterprise System Cookie authentication context, so they represent the same signed-in user and reuse that user's existing permissions. The menu requires only a nested Agent entry. The floating UI additionally requires the Enterprise System to manage its launcher/iframe and provide a secure page-change bridge, but Enterprise System code does not resolve objects or invoke Agent and Tool APIs. The surfaces can also share a bootstrap-validated active Chat Session, while only the floating UI consumes page changes. For each change, Core deterministically matches the normalized path against the configured HostApp Provider's Context routes, and that Provider resolves the visible business object and its current actions. The resulting Context is bound to the matching existing Skill and the authenticated user's permissions before it enters the normal Chat and Tool execution path. In standalone mode, AtlasClaw exposes an independent AI Agent interface that sits above multiple enterprise systems. In both cases, the core remains lightweight and reusable, while each Provider contains the system-specific integration logic.
  80. ### Core Architecture
  81. ![AtlasClaw core architecture](docs/images/architecture/v4-04-agent-core-components.png)
  82. The core runtime in this repository centers on:
  83. - `API Layer`: interactive APIs, WebSocket streaming, and webhook endpoints for both user-driven and programmatic invocation
  84. - `Agent Engine`: routing, prompt building, tool selection, and execution orchestration
  85. - `Session & Memory`: conversation context, persistence, and retrieval
  86. - `Tools & Skills`: reusable execution units exposed to the agent
  87. - `Provider Registry`: registration and discovery of enterprise integrations
  88. - `Execution Context`: dependency injection for auth, tenant, and runtime-scoped data
  89. ## Repository Layout
  90. ```text
  91. project-root/
  92. ├── app/atlasclaw/api/ # REST, SSE, WebSocket, gateway orchestration
  93. ├── app/atlasclaw/agent/ # Agent runner, routing, streaming, prompt building
  94. ├── app/atlasclaw/channels/ # Channel adapters and registries
  95. ├── app/atlasclaw/core/ # Config, execution context, provider registry
  96. ├── app/atlasclaw/memory/ # Memory manager and retrieval
  97. ├── app/atlasclaw/session/ # Session context, queue, and manager
  98. ├── app/atlasclaw/skills/ # Skill loading and registry
  99. ├── app/atlasclaw/tools/ # Built-in tools and tool catalog
  100. ├── app/atlasclaw/workflow/ # Workflow engine and orchestrator
  101. ├── docs/ # Concepts, tools, channels, and design notes
  102. └── tests/ # Pytest test suite
  103. ```
  104. ## Quick Start
  105. ### Requirements
  106. - Python 3.11+
  107. - A virtual environment is recommended
  108. - Access to an LLM provider and target enterprise systems for end-to-end integration
  109. ### Install Dependencies
  110. ```bash
  111. python3 -m venv .venv
  112. source .venv/bin/activate
  113. pip install -r requirements.txt
  114. ```
  115. For development and test execution, install the development manifest instead;
  116. it includes all runtime dependencies plus the test runner:
  117. ```bash
  118. pip install -r requirements-dev.txt
  119. ```
  120. ### Configure Environment
  121. AtlasClaw uses `atlasclaw.json` for configuration. Create a configuration file in the project root:
  122. ```json
  123. {
  124. "providers_root": "../atlasclaw-providers/providers",
  125. "model": {
  126. "primary": "kimi/kimi-k2.5",
  127. "temperature": 0.7,
  128. "providers": {
  129. "kimi": {
  130. "base_url": "${ANTHROPIC_BASE_URL}",
  131. "api_key": "${ANTHROPIC_API_KEY}",
  132. "api_type": "anthropic"
  133. }
  134. }
  135. }
  136. }
  137. ```
  138. The example above assumes a sibling `atlasclaw-providers` repository. The
  139. schema default for `providers_root` remains `../providers`.
  140. Configuration options:
  141. - `providers_root` - Root directory for provider packages, resolved relative to `atlasclaw.json` (schema default: `../providers`)
  142. - Provider skills discovered under `providers_root` are registered as `provider:skill` to avoid name collisions
  143. - `model.primary` - Primary model in format `provider/model-name`
  144. - `model.providers` - Provider configurations with `base_url`, `api_key`, and `api_type`
  145. - `api_type` - API type: `openai` (default) or `anthropic`
  146. Environment variables are expanded from `${VAR_NAME}` format. Set them before starting:
  147. ```bash
  148. # For Kimi (Anthropic-compatible API)
  149. export ANTHROPIC_BASE_URL="https://api.moonshot.cn/anthropic"
  150. export ANTHROPIC_API_KEY="your-api-key"
  151. # For Doubao (OpenAI-compatible API)
  152. export DOUBAO_BASE_URL="https://ark.cn-beijing.volces.com/api/v3"
  153. export DOUBAO_API_KEY="your-api-key"
  154. ```
  155. ### Run Tests
  156. ```bash
  157. # Run all tests
  158. pytest tests/atlasclaw -q
  159. # Run LLM integration tests (requires API credentials)
  160. export ANTHROPIC_BASE_URL="https://api.moonshot.cn/anthropic"
  161. export ANTHROPIC_API_KEY="your-api-key"
  162. pytest tests/atlasclaw/test_agent_integration.py -v -m llm
  163. # Run e2e tests (requires running service)
  164. pytest tests/atlasclaw/test_e2e_api.py -v -m e2e
  165. ```
  166. ### Start the Service
  167. Start the backend API server:
  168. ```bash
  169. uvicorn app.atlasclaw.main:app --reload --host 0.0.0.0 --port 8000
  170. ```
  171. The API will be available at `http://127.0.0.1:8000`.
  172. ### Access the Web UI
  173. Once the service is running, open your browser and navigate to:
  174. ```
  175. http://127.0.0.1:8000/
  176. ```
  177. The Web UI provides:
  178. - Chat interface powered by DeepChat
  179. - Real-time streaming responses via SSE
  180. - Multi-language support (Chinese / English)
  181. - Session management with conversation history
  182. ### Frontend Development
  183. The frontend is located in `app/frontend/` and supports two deployment modes:
  184. **Open Source Mode** (default):
  185. - Source files are served directly without bundling
  186. - No build step required
  187. - Edit files in `app/frontend/scripts/` and refresh browser
  188. **Enterprise Mode**:
  189. ```bash
  190. cd app/frontend
  191. npm install
  192. npm run build
  193. ```
  194. - Produces minified `dist/app.min.js`
  195. - Update `index.html` to reference the bundled file
  196. **Run Frontend Tests**:
  197. ```bash
  198. cd app/frontend
  199. npm test
  200. ```
  201. ## Development Notes
  202. - Entry point: `app/atlasclaw/main.py` - FastAPI application with lifespan management
  203. - The API surface lives under `app/atlasclaw/api/`
  204. - Core orchestration logic lives under `app/atlasclaw/agent/`, `app/atlasclaw/workflow/`, and `app/atlasclaw/tools/`
  205. - Provider integrations are loaded from `providers_root` (schema default: `../providers`; common sibling-repo layout: `../atlasclaw-providers/providers`)
  206. If you are integrating AtlasClaw into a host service, start by wiring the API layer, execution context, provider registry, and session manager together in your application bootstrap.
  207. ## Further Reading
  208. - [Architecture Concepts](docs/ARCHITECTURE.MD)
  209. - [Tooling Documentation](docs/UNIFIED_PROVIDER_TOOL_CONTRACT.md)
  210. - [Channel Documentation](docs/CHANNEL-GUIDE.MD)
  211. - [Automation Documentation](docs/automation/webhook.md)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.