IX

Provides a React-based drag-and-drop interface for constructing AI agent workflows as directed acyclic graphs. Components (LLMs, tools, memory systems, retrievers) are visually connected as nodes with configurable parameters, then compiled into executable LangChain runnables. The editor maintains a relational data model of chain definitions that map to LangChain's component registry, enabling non-technical users to compose complex agent logic without writing code.

Enables multiple autonomous agents to collaborate within a single chat session by maintaining a shared task context and conversation history. Each agent can execute its assigned chain, access previous messages and artifacts from other agents, and contribute results back to the conversation. The system uses a task-based execution model where each user interaction spawns a task that routes to the appropriate agent(s), with all outputs logged and accessible to subsequent agents.

Provides a web-based chat interface for interacting with agents in real-time. Users send messages, which are routed to the appropriate agent(s) based on chain configuration. Agent responses stream back in real-time through WebSocket connections, with intermediate steps (tool calls, reasoning) displayed as they occur. The interface includes a sidebar for viewing generated artifacts (code, documents, images) with preview capabilities. Users can manage conversation history, create new tasks, and switch between agents within the same session.

Provides a component registry that maps LangChain classes to visual node types in the chain editor. New components can be registered by defining a configuration object with metadata (name, description, input/output schemas). The system dynamically generates UI forms for component configuration based on the schema. Custom components can be added by extending the registry without modifying the core platform. The registry supports versioning of components, enabling backward compatibility as components evolve.

Tracks individual agent execution instances as tasks, capturing full execution logs, generated artifacts, and conversation history. Each task maintains a relational link to the chain definition, agent, user, and all outputs produced during execution. Artifacts (generated code, documents, images, etc.) are stored separately with metadata and can be grouped, versioned, and retrieved through REST/GraphQL APIs. The system provides structured logging at each step of chain execution, enabling debugging and performance analysis.

Exposes chain definitions, agent configurations, task execution, and artifact retrieval through both REST and GraphQL endpoints. The REST API provides CRUD operations on chains, agents, and tasks with standard HTTP semantics. The GraphQL API enables complex queries combining chains, agents, tasks, and artifacts with flexible filtering and pagination. Both APIs support authentication, authorization, and rate limiting. The API layer abstracts the underlying LangChain execution, allowing external systems to trigger agent execution and retrieve results.

Abstracts multiple LLM providers (OpenAI, Anthropic, Google, local Ollama, etc.) behind a unified component interface. Users configure LLM credentials and model selection in the platform settings, then reference LLM components in chains by name without embedding API keys. The system supports dynamic provider switching, model parameter tuning (temperature, max_tokens, etc.), and fallback chains if a provider fails. Configuration is stored securely in the database with environment variable substitution for sensitive credentials.

Enables agents to call external tools and APIs through a schema-based function registry. Tools are defined as LangChain Tool objects with JSON schemas describing inputs/outputs, then registered in the platform. When an agent needs to use a tool, the LLM generates a function call matching the schema, which is routed to the appropriate tool implementation. The system supports native function calling APIs (OpenAI, Anthropic) when available, and falls back to prompt-based tool use for other providers. Tool results are automatically parsed and returned to the agent.

Provides multiple memory types (conversation history, entity memory, summary memory, vector-based retrieval) that agents can use to maintain context across interactions. Memory components are configured in the chain editor and integrated with the task execution system. The platform supports different storage backends (in-memory, database, Redis) for different memory types, with automatic context window management to prevent token overflow. Memory can be scoped to individual conversations, users, or agents, with configurable retention policies.

Enables agents to ingest documents (PDFs, web pages, text files) and retrieve relevant context using semantic search. Documents are chunked, embedded using a configurable embedding model, and stored in a vector database. When an agent needs context, it performs semantic search to retrieve the most relevant chunks, which are injected into the LLM prompt. The system supports multiple document sources (file upload, web crawling, API integration) and vector backends (Pinecone, Weaviate, Chroma, etc.). Retrieval can be configured with different search strategies (similarity, MMR, fusion) and result filtering.

Provides detailed execution traces for agent chains, showing each step of execution with inputs, outputs, and intermediate results. The chat interface displays agent reasoning in real-time, including tool calls, LLM responses, and decision points. Users can inspect the execution trace to understand why an agent made a particular decision or where it failed. The system captures timing information for each step, enabling performance profiling. Traces are persisted in the task log and can be replayed or analyzed post-execution.

Packages the entire IX platform (React frontend, Django/FastAPI backend, task queue, database) as Docker containers orchestrated with Docker Compose. The deployment includes pre-configured services for PostgreSQL, Redis, and optional services for vector databases. Users can deploy IX on any Docker-compatible infrastructure (local machine, cloud VMs, Kubernetes). The system includes GitHub Actions workflows for automated testing, building, and publishing Docker images. Configuration is managed through environment variables and Docker Compose overrides, enabling easy customization for different deployment environments.