Frequently Asked Questions

ChaozCode is an AI-powered development platform that provides persistent memory, intelligent code analysis, and multi-agent orchestration. It helps developers write better code faster by maintaining context across sessions and providing AI assistance that understands your entire codebase.

Key features include:

• Memory Spine - Persistent AI memory with 62 MCP tools
• Zearch - Intelligent search with 300+ API endpoints
• Multi-Agent System - 20+ specialized AI agents
• Code Analysis - Deep codebase understanding

While ChatGPT and Copilot are excellent tools, ChaozCode offers unique capabilities:

• Persistent Memory - Unlike ChatGPT which forgets after each session, ChaozCode remembers everything through Memory Spine
• Codebase Understanding - Full semantic analysis of your entire project, not just the current file
• Multi-Agent Orchestration - Specialized agents for different tasks (code review, testing, documentation)
• Self-Hosted Option - Run on your own infrastructure for complete data control
• Extensible - 600+ tools and growing, with custom agent support

ChaozCode supports all major programming languages including:

• JavaScript/TypeScript, Python, Go, Rust, Java, C/C++, C#
• Ruby, PHP, Swift, Kotlin, Scala, Haskell
• HTML, CSS, SQL, Markdown, YAML, JSON

The code analysis engine uses semantic understanding, so it works with any language that has parseable syntax. Language-specific features (like type inference) are enhanced for popular languages.

The cloud version requires internet connectivity. However, ChaozCode offers a self-hosted option for Enterprise customers that can run entirely on your own infrastructure, enabling offline usage.

The self-hosted version includes:

• Full Memory Spine with all 62 tools
• Local LLM integration (Ollama, vLLM)
• Complete API compatibility
• Air-gapped deployment support

Memory Spine is ChaozCode's persistent memory system that stores and retrieves context across all your AI interactions. It uses vector embeddings for semantic search, meaning it understands the meaning of your queries, not just keyword matching.

Memory Spine provides 62 MCP (Model Context Protocol) tools organized into categories:

• Core Operations - store, search, retrieve, update, delete
• Context Building - llm_context_window, summarize, insights
• Knowledge Graphs - build relationships between memories
• Codebase Analysis - analyze, suggest, generate code
• Maintenance - deduplication, consolidation, archiving

Memories are retained indefinitely by default. However, you can configure retention policies:

• Pinned memories - Never deleted, always available
• Regular memories - Retained until manually deleted or consolidated
• Temporary memories - Auto-delete after configurable period (1 day to 1 year)

The memory_lifecycle_rules tool lets you configure automatic archival and deletion policies.

Storage limits vary by plan:

• Free - 1,000 memories, 10MB total
• Pro - 50,000 memories, 500MB total
• Enterprise - Unlimited (self-hosted infrastructure)

Each individual memory can be up to 100KB. Use the memory_stats() tool to check your current usage.

Yes, you can export all your memories using the memory_export tool:

// Export all memories
const exported = await client.memory.export({
  format: 'json',  // or 'csv', 'markdown'
  limit: -1        // -1 = all
});

// Export filtered subset
const filtered = await client.memory.export({
  query: 'tag:important',
  format: 'json'
});

Exports include all metadata, tags, and relationships. Vector embeddings are not included but can be regenerated on import.

Rate limits by tier:

• Free - 100 requests/minute, 1,000/day
• Pro - 500 requests/minute, 50,000/day
• Enterprise - 2,000+ requests/minute, unlimited daily

Rate limit headers are included in every response:

X-RateLimit-Limit: 500
X-RateLimit-Remaining: 423
X-RateLimit-Reset: 1706612400

Yes, we provide official SDKs for:

• JavaScript/TypeScript - npm install @chaozcode/sdk
• Python - pip install chaozcode
• Go - go get github.com/chaozcode/chaozcode-go
• Rust - chaozcode = "0.1" in Cargo.toml

Community SDKs are available for Ruby, PHP, Java, and C#. All SDKs are open source on GitHub.

Yes, ChaozCode supports multiple LLM providers:

• OpenAI - GPT-4, GPT-3.5
• Anthropic - Claude 3 Opus, Sonnet, Haiku
• Google - Gemini Pro, Ultra
• Self-hosted - Ollama, vLLM, LocalAI

const client = new ChaozCode({
  apiKey: 'your_key',
  llmProvider: 'openai',
  llmApiKey: process.env.OPENAI_API_KEY,
  llmModel: 'gpt-4-turbo'
});

Yes, ChaozCode provides WebSocket connections for:

• Streaming responses - Real-time token-by-token output
• Event subscriptions - Memory changes, agent completions
• Agent communication - Real-time agent coordination

const ws = new WebSocket('wss://api.chaozcode.com/ws');
ws.send(JSON.stringify({
  type: 'subscribe',
  events: ['memory.stored', 'agent.completed']
}));

ChaozCode provides 20+ specialized agents:

• explore - Codebase exploration and search
• code-generator - Generate code from descriptions
• code-review - Review code for issues
• test-specialist - Generate and run tests
• security-auditor - Security vulnerability analysis
• documentation-master - Generate documentation
• database-expert - SQL and database optimization
• devops-automator - CI/CD and deployment
• performance-tuner - Performance optimization
• memory-specialist - Memory Spine operations

Yes, you can create custom agents with specific capabilities and behaviors:

// Custom agent definition
{
  "name": "my-agent",
  "description": "Specialized for my project",
  "model": "gpt-4-turbo",
  "systemPrompt": "You are an expert in...",
  "tools": ["memory_search", "codebase_analyze"],
  "temperature": 0.7
}

Custom agents can be shared across your team and versioned like code.

Agents coordinate through Memory Spine and the THERO orchestration system:

• Shared Memory - All agents access the same Memory Spine
• Task Queue - Tasks are distributed via a priority queue
• Handoffs - Agents can transfer context to other agents
• Parallel Execution - Multiple agents work simultaneously

// Orchestrate multiple agents
await client.orchestrate({
  tasks: [
    { agent: 'explore', prompt: 'find auth code' },
    { agent: 'code-review', prompt: 'review changes' },
    { agent: 'test-specialist', prompt: 'generate tests' }
  ],
  parallel: true
});

ChaozCode offers three tiers:

• Free - Perfect for trying out the platform
  • 100 API calls/day
  • 1,000 memories
  • 5 agents
• Pro ($49/month) - For individual developers and small teams
  • 50,000 API calls/day
  • 50,000 memories
  • All agents
  • Priority support
• Enterprise (Custom) - For organizations with advanced needs
  • Unlimited API calls
  • Self-hosted option
  • Custom agents
  • SSO/SAML
  • Dedicated support

Yes, you can change your plan at any time:

• Upgrades - Take effect immediately, prorated for the billing period
• Downgrades - Take effect at the end of your current billing period
• Cancellation - Access continues until end of paid period

Your memories and settings are preserved when changing plans. If you exceed the new plan's limits, you'll need to reduce usage or upgrade.

We offer a 14-day money-back guarantee for new Pro subscriptions. If you're not satisfied, contact support within 14 days of your first payment for a full refund.

Enterprise contracts have custom terms negotiated during the sales process.

ChaozCode implements multiple layers of security:

• Encryption in Transit - All data encrypted with TLS 1.3
• Encryption at Rest - AES-256 encryption for stored data
• API Key Security - Keys hashed with SHA-256, never stored in plaintext
• Memory Isolation - Each user's memories are completely isolated
• SOC 2 Compliant - Regular third-party audits

When using cloud features, code snippets may be sent to LLM providers (OpenAI, Anthropic) for processing. However:

• We have data processing agreements with all providers
• Code is not used for training AI models
• Data is deleted after processing
• Enterprise customers can use self-hosted LLMs for complete isolation

Yes, ChaozCode is fully GDPR compliant:

• Data Portability - Export all your data anytime
• Right to Deletion - Delete your account and all associated data
• Data Processing Agreements - Available for Enterprise customers
• EU Data Residency - Available on Enterprise plans

Yes, Enterprise customers can deploy ChaozCode on their own infrastructure:

• Docker/Kubernetes deployment
• On-premises or private cloud
• Air-gapped environment support
• Integration with local LLMs (Ollama, vLLM)
• Full feature parity with cloud version

Contact sales@chaozcode.com for self-hosted deployment options.