AI that shows its work.
Cognotik is a comprehensive, JVM-native AI-powered development platform that combines intelligent planning, code generation, document pipelines, and interactive interfaces to streamline software development workflows. Unlike black-box AI tools, every step of every pipeline is visible, auditable, and stored as readable files — making AI outputs reproducible, trustworthy, and version-controllable.
Built natively on the JVM in Kotlin, Cognotik runs in your existing Java/Kotlin ecosystem without Python bridges, conda environments, or cross-language friction. The platform consists of multiple integrated components that work together to provide a complete solution for AI-assisted development — from IDE integration to standalone web applications to a full document-operations pipeline.
# Clone the repository
git clone https://github.com/SimiaCryptus/Cognotik.git
cd Cognotik
# Build the project
./gradlew build
# Run the desktop application
./gradlew :desktop:runFor detailed installation instructions, see the Installation Guide.
| Feature | Cognotik | Typical AI Tools |
|---|---|---|
| Architecture | ✅ JVM-native: Built in Kotlin, runs natively in Java/Kotlin ecosystems | 🔶 Python-first with JVM support as an afterthought |
| Transparency | ✅ File-based state: Every input, output, and intermediate step is a readable, auditable file | ❌ Opaque conversation history with no audit trail |
| Model Control | ✅ Bring Your Own Key (BYOK): Use any compatible LLM, including local or fine-tuned models | ❌ Locked into a single provider's models |
| Data Privacy | ✅ Your infrastructure: Code and data go directly to the provider you choose, or stay local | ❌ Data passes through intermediary servers |
| Source Code | ✅ Open Source (Apache 2.0): Full transparency — inspect, modify, contribute | ❌ Closed source black box |
| Reproducibility | ✅ Pipeline artifacts in Git: Re-run, diff, and trace any output to its source | ❌ Non-deterministic, non-reproducible outputs |
| Core Focus | ✅ Agentic pipelines: Multi-step workflows with explicit user control and oversight | 🔶 Primarily autocomplete or single-turn chat |
Cognotik is 100% open source software, released under the Apache 2.0 license. The platform follows a "Bring Your Own Key" (BYOK) model, meaning you provide your own API keys for AI services (OpenAI, Anthropic, etc.). This gives you complete control over:
- Which AI providers and models you use
- Your data privacy and security
- Your usage costs and billing
- Service configuration and customization
Cognotik uses a "Bring Your Own Key" (BYOK) model for all AI service integrations:
- You must provide your own API keys for services like OpenAI, Anthropic, Google AI, etc.
- All API usage costs are billed directly to your accounts with these providers
- No data is shared with any third parties without your explicit configuration
- The software includes usage tracking tools to help you monitor your API consumption
- OpenAI (GPT-4, GPT-3.5, DALL-E)
- Anthropic (Claude 3, Claude 2)
- Google (Gemini, PaLM)
- AWS Bedrock (Various models)
- Azure OpenAI (GPT models)
- Groq (Fast inference)
- Mistral AI (Mistral models)
- DeepSeek (Coding models)
- Perplexity (Search-optimized models)
- Local Models (Ollama, LM Studio)
A collection of AI-powered web applications built on a shared document-operations ("doc ops") platform. Each app transforms user input through one or more AI pipeline stages to produce rich, structured outputs — all from the browser with no local build tools required.
Included Applications:
| App | Description |
|---|---|
| 🧮 Philosophical Calculator | Multi-perspective analytical toolkit — dialectical analysis, Socratic dialogue, game theory, persuasive essays, and more |
| 📚 Comic Serial Generator | Transforms story ideas into an ongoing comic book series with consistent characters and arcs |
| 🧙 System Wizard | Describe a goal in plain language → generates, runs, and auto-fixes a shell script |
| 🏗️ Webapp Builder | Turns natural language descriptions into complete, runnable web apps |
| 🔮 Omega — App Factory | Meta-application that designs and produces other DocOps applications from plain language |
See the DocOps App Suite README for architecture details and the Guided Tour for a walkthrough of each application.
The foundation of the platform, providing essential services and utilities for AI interactions.
Key Features:
- Actor system for AI model interactions (SimpleActor, CodingActor, ImageActor)
- Session management and data persistence
- Authentication and authorization
- Code patch generation and application utilities
- Extensible interpreter framework for code execution
- Token counting and cost estimation
- Rate limiting and retry logic
A framework for building interactive web applications with real-time communication.
Key Features:
- Chat system with real-time communication
- Session management and state persistence
- Interactive UI components (links, inputs, tasks, file handling)
- Application framework for building web interfaces
- Local storage management
- File upload and download capabilities
- Session history and management
AI-assisted task planning and execution framework.
Key Features:
- Task types for file modifications, code generation, and web searches
- Plan coordination with dependency management
- Plan visualization tools
- Multiple cognitive modes (AutoPlanMode, PlanAheadMode, GoalOrientedMode, TaskChatMode, GraphOrderedPlanMode)
- Self-healing task execution
A standalone desktop application that hosts the Cognotik platform.
Key Features:
- System tray integration for easy access
- Background daemon process
- Socket-based communication for remote control
- Cross-platform support (Windows, macOS, Linux)
- Auto-update functionality
A React-based chat application interface with real-time messaging.
Key Features:
- WebSocket connectivity for real-time updates
- Multiple themes with dynamic switching
- Markdown support with syntax highlighting
- Tab system with state persistence
- Event-driven architecture for real-time updates
An IntelliJ-based plugin that integrates Cognotik capabilities into the IDE.
Key Features:
- Smart code operations (paste, transformations)
- Contextual AI chat with code understanding
- Intelligent workflows for multi-step changes
- Test result autofix and problem analysis
- Code review and documentation generation
- Refactoring suggestions
The Cognotik platform follows a modular architecture:
-
Core Services Layer: Provided by the Core module, handling AI interactions, session management, and file-based persistence.
-
Application Layer: Consists of the Web UI Framework, Planning Framework, and DocOps App Suite, providing the building blocks for AI-powered applications and ready-to-use tools.
-
Client Applications: Desktop Application, Web Application, and IntelliJ Plugin, offering different interfaces to access the platform.
-
Model Integration Layer: JOpenAI provides a unified interface to various AI models and providers.
Communication between components:
- RESTful APIs and WebSockets for client-server communication
- Socket-based communication for desktop application components
- File-based storage for session data and generated content
- Java 17 or higher
- Node.js 16+ (for web application)
- Gradle 7.6+ (for building)
- API keys for supported AI providers (OpenAI, Anthropic, etc.)
-
Download the appropriate package for your platform:
- Windows: Download MSI installer
- macOS: Download DMG package
- Linux: Download DEB/RPM package
-
Run the installer and follow the instructions.
-
Launch the application from your desktop or start menu.
-
Configure your API keys in Settings → API Configuration.
- Install from the JetBrains Marketplace:
- Open IntelliJ IDEA
- Go to Settings/Preferences > Plugins
- Search for "Cognotik"
- Click Install and restart the IDE
- Configure API keys:
- Go to Settings/Preferences > Tools > Cognotik
- Enter your API keys for the providers you want to use
-
Clone the repository
-
Build using Gradle:
./gradlew build
-
For specific components:
# Desktop application ./gradlew :desktop:build # IntelliJ plugin ./gradlew :intellij:buildPlugin # Web application cd webapp npm run build
-
Clone the repository
-
Install dependencies:
cd webapp npm install -
Configure environment variables:
cp .env.example .env # Edit .env with your API keys -
Start the development server:
npm start
-
Open your browser and navigate to
http://localhost:3000
cognotik/
├── core/ # Core services and utilities
├── webui/ # Web UI framework
├── desktop/ # Desktop application
├── webapp/ # Web application (React)
├── intellij/ # IntelliJ plugin
├── gradle/ # Gradle configuration
└── docs/ # Documentation
The platform provides several extension points for customization:
- Actors: Create custom actors for specialized AI interactions
- Interpreters: Add support for new programming languages
- Storage Providers: Implement custom storage solutions
- Authentication Providers: Integrate with identity providers
- UI Components: Create custom UI components for the web interface
Use the IntelliJ plugin or web interface to:
- Generate code from natural language descriptions
- Refactor existing code with AI assistance
- Get explanations and documentation for complex code
- Fix bugs and implement features with AI guidance
Use the planning framework to:
- Break down complex development tasks into manageable steps
- Generate implementation plans with proper dependencies
- Execute tasks with AI assistance
- Visualize and track progress
Use the platform's knowledge tools to:
- Extract structured data from documentation
- Create searchable knowledge indexes
- Generate documentation from code
- Visualize document relationships
Leverage AI for:
- Security vulnerability detection
- Performance optimization suggestions
- Code quality metrics
- Architecture analysis
- Dependency management
Use the DocOps App Suite to:
- Analyze content through multiple philosophical and rhetorical lenses
- Generate complete web applications from natural language descriptions
- Create serialized comic book series with consistent characters and arcs
- Automate system tasks with self-healing shell scripts
- Design and generate custom AI pipeline applications with Omega
- Build multi-round diagnostic and analytical workflows
- 📚 Documentation: Full documentation
- 🐛 Issue Tracking: GitHub Issues
We welcome contributions! Please see our Contributing Guide for details on:
- Code of Conduct
- Development setup
- Submitting pull requests
- Reporting issues
- Feature requests
This project is licensed under the Apache 2.0 License - see the LICENSE file for details. As open source software, you are free to use, modify, and distribute the code according to the terms of the license.
- OpenAI, Anthropic, and other AI providers for their powerful models
- JetBrains for the IntelliJ platform
- The open-source community for various libraries and tools used in the project
- All contributors who have helped improve Cognotik
See our public roadmap for upcoming features and improvements.
Made with ❤️ by the Cognotik Team
AI that shows its work.