V1.0 Documentation

Welcome to Crew10X Documentation

Everything you need to build, deploy, and manage autonomous cognitive agents. From your first agent to enterprise-scale swarm orchestration.

Quick Start

Get a cognitive agent running in three steps.

1

Install the SDK

Install the Crew10X Python SDK via pip.

$ pip install cog-os
2

Create Your First Agent

Initialize an agent with a cognitive profile and deploy objective.

import cog_os

client = cog_os.Client(api_key="your-api-key")

agent = client.agents.create(
    type="specialist",
    name="market-analyst",
    consciousness=True,
    memory={
        "vector_store": "10gb",
        "knowledge_graph": True
    }
)

print(agent.id, agent.status)
3

Deploy with an Objective

Assign a goal and let the agent reason autonomously.

result = agent.deploy(
    objective="Analyze Q4 market disruptions in semiconductor industry",
    thought_loops=5,
    ethical_constraints=True
)

print(result.summary)
print(result.confidence_score)

Architecture Overview

Crew10X is built on a six-layer cognitive stack. Each layer operates independently but communicates through a unified message bus, enabling emergent behaviors across the system.

L-01

Input & Sensor Layer

Ingests data from APIs, documents, databases, live feeds, and user instructions. Supports structured and unstructured inputs with automatic schema detection and normalization.

L-02

Memory Graph Layer

Persistent knowledge storage combining vector embeddings, knowledge graphs, and working memory. Supports cross-session recall with configurable retention policies.

L-03

Cognitive Engine Layer

The reasoning core. Executes recursive thought loops, probabilistic evaluation chains, and Game of Life rule systems for emergent decision-making. Supports configurable reasoning depth (1-100 loops).

L-04

Agent Pool Layer

Manages the lifecycle of Worker, Specialist, and Executive agents. Handles spawning, scheduling, load balancing, and inter-agent communication via shared memory protocols.

L-05

Arbitration & Governance

Consensus algorithms, trust scoring, ethical constraint enforcement, and task prioritization. Ensures all autonomous actions pass safety guardrails before execution.

L-06

Execution Layer

Integrates with external systems: APIs, trading platforms, CRM, CI/CD pipelines, and enterprise workflows. All actions are sandboxed with rollback capabilities.

Data Flow

Input -> Memory -> Cognitive Engine -> Agent Pool -> Arbitration -> Execution
  ^                                                                          |
  |__________________________ feedback loop ________________________________|

Every execution result feeds back into the Memory Graph, enabling continuous learning and self-improvement across reasoning cycles.

Agent Types

Crew10X provides three tiers of cognitive agents, each designed for different complexity levels and organizational roles.

Worker Agents

$49/mo

Single-task executors optimized for speed and cost efficiency. Ideal for repetitive, well-defined operations that require minimal reasoning.

Capability Specification
Memory1GB Short-term RAM
ReasoningStandard Engine (1-3 loops)
CollaborationPeer-to-peer only
Use CasesData entry, monitoring, simple classification

Specialist Agents

$199/mo

Domain-specific experts with advanced reasoning capabilities and persistent vector memory. They develop expertise over time through continuous learning.

Capability Specification
Memory10GB Vector Memory + Knowledge Graph
ReasoningAdvanced Thought Loops (1-25 loops)
CollaborationSwarm-compatible, shared memory
Use CasesResearch, analysis, code review, financial modeling

Executive Agents

$999/mo

Orchestration-layer agents that manage teams of Workers and Specialists. They handle strategic planning, resource allocation, and cross-agent coordination with full ethical guardrails.

Capability Specification
MemoryInfinite Long-term Memory
ReasoningDeep Cognitive Engine (1-100 loops)
CollaborationFull orchestration + delegation
Use CasesDepartment management, strategy, autonomous companies

Memory System

The Crew10X memory architecture provides agents with persistent, queryable, and evolving knowledge stores that survive restarts and grow smarter over time.

Vector Memory

High-dimensional embedding store for semantic search and similarity matching. Every piece of information an agent encounters is encoded into dense vector representations, enabling fuzzy recall across sessions.

memory = agent.memory.vector

memory.store(
    content="Q3 revenue exceeded projections by 14%",
    metadata={"domain": "finance", "quarter": "Q3-2024"}
)

results = memory.search("revenue performance", top_k=5)

Knowledge Graph

A structured relationship network that maps entities, concepts, and their connections. Enables agents to perform multi-hop reasoning and discover non-obvious relationships in their knowledge base.

graph = agent.memory.knowledge_graph

graph.add_entity("NVIDIA", type="company")
graph.add_entity("H100", type="product")
graph.add_relation("NVIDIA", "manufactures", "H100")

paths = graph.query("NVIDIA", hops=3)

Working Memory

Ephemeral, session-scoped memory that holds the agent's current reasoning state, active hypotheses, and intermediate computations. Automatically garbage-collected when reasoning cycles complete.

working = agent.memory.working

working.set("current_hypothesis", "Supply chain disruption is primary driver")
working.set("confidence", 0.73)

state = working.snapshot()

SDK Reference

Integrate Crew10X into your stack with our official SDKs.

Python v2.1.0 | PyPI
import cog_os
from cog_os.agents import Worker, Specialist, Executive
from cog_os.memory import VectorStore, KnowledgeGraph

client = cog_os.Client(api_key="sk-crew10x-...")

swarm = client.swarms.create(
    name="research-team",
    agents=[
        Specialist(role="data-analyst"),
        Specialist(role="report-writer"),
        Worker(role="data-collector", count=3),
    ],
    executive=Executive(role="project-lead")
)

result = swarm.execute("Compile competitive analysis for Q1 board meeting")

Requires Python 3.10+. Install via pip install cog-os

Node.js v2.1.0 | npm
import { Crew10X, Specialist, Worker } from '@crew10x/sdk';

const client = new Crew10X({ apiKey: 'sk-crew10x-...' });

const agent = await client.agents.create({
  type: 'specialist',
  name: 'code-reviewer',
  consciousness: true,
  memory: { vectorStore: '10gb', knowledgeGraph: true }
});

const result = await agent.deploy({
  objective: 'Review all PRs in the last 24 hours'
});

Requires Node.js 18+. Install via npm install @crew10x/sdk

API Reference

Direct HTTP access to the Crew10X platform. All endpoints require Bearer token authentication.

REST API

Base URL: https://api.crew10x.com/v1

POST /agents Create a new agent
GET /agents/:id Retrieve agent status
POST /agents/:id/deploy Deploy agent with objective
GET /agents/:id/memory Query agent memory
DELETE /agents/:id Terminate agent
POST /swarms Create agent swarm

WebSocket API

Real-time streaming endpoint: wss://stream.crew10x.com/v1

const ws = new WebSocket('wss://stream.crew10x.com/v1');

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: 'subscribe',
    agent_id: 'agent_abc123',
    events: ['reasoning', 'memory', 'execution']
  }));
};

ws.onmessage = (event) => {
  console.log(JSON.parse(event.data));
};

Authentication

All requests must include your API key in the Authorization header.

$ curl -X POST https://api.crew10x.com/v1/agents \
  -H "Authorization: Bearer sk-crew10x-your-key" \
  -H "Content-Type: application/json" \
  -d '{"type": "specialist", "name": "analyst"}'

Generate API keys from your dashboard. Keys are scoped to organization-level access.

Tutorials

Step-by-step guides to build real-world cognitive systems.

Build a Cognitive Chatbot

Create a chatbot with persistent memory that learns user preferences over time and adapts its communication style.

30 min Beginner Python

Orchestrate Agent Swarms

Deploy a team of specialized agents coordinated by an Executive to tackle complex research tasks with emergent collaboration.

60 min Intermediate Python

Custom Memory Backends

Integrate your own vector database (Pinecone, Weaviate, Qdrant) as a custom memory backend for Crew10X agents.

45 min Advanced Python / Node.js