Just-Chat

How Our Project Will Contribute To The Growth Of The Decentralized AI Platform

Democratizing AI: Removing AI "vendor-locks" through one-click deployment and no-code customization. Making AI agents "open and accessible to all" with safe, controlled operation.

Community Empowerment: Educational platform enabling user progress from basic to advanced AI use. Fostering community learning and growth.

Decentralized Innovation: custom tools, interchangeable LLMs. Strong security and privacy through local deployment and containerization. Full transparency via open-source.

Our Team

Nikolai Usanov (https://github.com/winternewt) - bioinformatician, dev-ml-ops, developer 
Anton Kulaga (github.com/antonkulaga) – bioinformatician, aging researcher & ML open-source developer 
Livia Zaharia (github.com/Livia-Zaharia) – Type 1 diabetic, open-source developer & architect 
Alex Karmazin (https://github.com/Alex-Karmazin) - Senior Developer, ML engineer
Maria Koval (https://github.com/marfantyk) - Software Developer, Designer

Company Name (if applicable)

The core problem we are aiming to solve

AI tech today presents users with two choices: polished but closed corporate solutions that compromise privacy, or flexible open-source alternatives requiring technical skills and resources. This creates a barrier for professionals, educators, and creators who value privacy or seek advanced functionality but are not devs.
The challenge is to democratize working with AI agents without sacrificing customization and allowing modularity.. Users do not have to choose between oversimplified interfaces and complex implementations requiring specialized skill sets.
This accessibility gap stifles innovation and limits AI adoption across sectors where it could drive advancement and efficiency gains. 

Our specific solution to this problem

Just Chat makes advanced AI use patterns and AI-agents creation accessible without compromising privacy or requiring technical expertise. 
Users can start with basic chat functionality and progressively explore more advanced features as their needs evolve, all within a secure and reliable microservices architecture. This solution eliminates the traditional trade-off between usability and customization, enabling users to focus on their specific use cases rather than technical implementation details. Modularity allows efficient teamwork and collaboration without interference
Key Features:
Instant Deployment: Launch your AI environment with a single Docker/podman command
Flexible Models: Supports numerous LLM providers with built-in Groq integration
No-code Configuration: Customize AI agents through YAML configurations
Collaboration: Develop and manage agents independently in parallel.
Python Extensibility: Leverage custom Python and external libraries as agent tools with no glue
Secure Architecture: Docker/Podman ensures consistent, isolated, secure and private crossplatform operation 
Independent Components: Modular design separates agents API, framework, web interface, database, no tight coupling
Universal Access: Web-based chat interface accessible from any device
Full Transparency and Zero cloud dependencies: Built entirely on open-source containers
Just Chat provides a scalable foundation for human-AI collaboration: ease of use, flexibility, modularity, privacy and transparency. 

Project details

Humans set themselves apart from apes by mastering the creation and use of tools—this simple yet profound advancement reshaped our evolution and expanded our capabilities dramatically. Today, a parallel transformation is happening through human-AI collaboration. Right now, people primarily interact with AI in the form of chat interfaces embedded within apps. While chats have made AI accessible, they represent only the earliest stage in the evolution of this relationship.

The next step forward involves humans equipping AI systems not just with prompts, but with specialized tools, clear roles, and task-specific AI agents. By giving AI these tools and structures, we empower it to perform complex tasks far beyond the limits of a simple chat interaction. Importantly, this isn't a one-sided enhancement—it's a two-player game in which both humans and AI benefit. As we equip AI with clearer roles and smarter tools, it becomes more effective at assisting us, solving problems, and automating tasks.

Meanwhile, humans learn valuable skills from collaborating with AI: we start understanding the strengths and limitations of a non-human form of intelligence. We discover how best to communicate tasks, clarify expectations, and provide feedback. Over time, humans become adept at managing interactions with AI, capitalizing on its strengths (such as memory, speed, and pattern recognition) while compensating for its weaknesses (like contextual ambiguity, lack of common sense, hallucinations).

However, for this collaboration to reach its true potential, it must move beyond interfaces meant primarily for the tech-savvy minority. Currently, technical expertise still creates barriers to deeper AI integration. The future lies in developing no-code, intuitive AI agents accessible through natural language—the most universally wielded tool among humans. Just as literacy once enabled wider access to knowledge, natural language interaction with AI agents can democratize the power of advanced technology. When AI interaction becomes intuitive and universal, anyone—not just developers or tech experts—will be able to leverage sophisticated AI-driven workflows and solutions.

Ultimately, by building this seamless bridge between humans and AI through natural language and specialized tools, we create an environment in which both parties grow. Humans gain deeper insight into collaborating with intelligent systems, and AI agents become ever more capable in their support roles, leading to unprecedented synergy and mutual advancement.

Bridging the Gap: From Concept to Implementation

Just Chat embodies this vision of seamless human-AI collaboration through a carefully crafted architecture that prioritizes accessibility without sacrificing capability. At its core, it provides a one-command deployment solution that instantly creates a secure, containerized environment for AI interaction. This environment serves as both a playground for exploration and a production-ready platform for serious applications.

The system's flexibility stems from its innovative YAML-based agent configuration system. Users can customize every aspect of their AI agents - from the underlying language model and API endpoints to specific roles, goals, and personas - all through simple text files. This approach democratizes AI agent creation while maintaining the power to implement advanced patterns like Retrieval-Augmented Generation (RAG), reasoning through Chain-of-Thought, Critics, Reflexion, multi-agent interactions and much more.

Technical Architecture and Capabilities

Just Chat's architecture is built on four core principles: security, modularity, extensibility and ease of use. The system runs entirely in userspace containers, with optional rootless deployment for enhanced security. It integrates seamlessly with any OpenAI-compatible API endpoint, supporting both cloud-based providers and local models through services like Ollama, enabling fully on-premise deployments with no external dependencies.

Initially, the project emerged from our need to modularize the development of diverse bioinformatic agents. We wanted to let each team member easily manage their own agents of interest without a need to rely on dev-ops effort in order to test and iterate on their agents and coding expertise for well-known patterns and prompt engineering tasks. Further, we discovered that the need is universal and is not limited by life-sciences; that is how Just-Chat was born. 

The platform's extensibility shines through its Python tools integration system. Users can enhance their agents' capabilities by simply defining tools in Python files and referencing them in YAML configurations:

tools:

  - package: "agent_tools.analysis"

function: "process_data"

  - package: "agent_tools.visualization"

function: "create_chart"

These tools are automatically discovered, validated, and made available to agents, with dependencies managed automatically through container restarts when necessary, dependencies are installed on init. Rebuilding containers to speed up initialization is also possible for complex setup. This approach allows for infinite extensibility while maintaining the system's zero-setup promise for end users.

Progressive Complexity: From Simple Chat to Advanced Workflows

What sets Just Chat apart is its ability to scale with user needs. A beginner can start with simple chat interactions, using the included Groq integration for immediate access to powerful language models. As their needs evolve, they can progressively explore more advanced features:

1. Basic chat with customizable personas

2. Integration of specialized Python tools

3. Implementation of advanced AI patterns (COT, reflection, etc.)

4. Creation of agent chains and tool composition

5. Development of self-modifying agent systems

Each level maintains the same simple interface while unlocking new capabilities. The built-in web interface serves multiple roles: chat platform, testing ground, development environment, and system monitor. Integrated logging and observability tools (through Langfuse and Comet Opik) provide insights into agent behavior and help manage hallucinations or errors. 

Vision and Impact

Just Chat aims to democratize access to advanced AI capabilities while fostering a community of builders and learners. By providing a platform that grows with its users - from educational toy to enterprise-ready solution - it enables organic skill development and experimentation. The project's commitment to open-source principles and local deployment ensures that users maintain control over their data and interactions while benefiting from the collective advancement of AI technology.

Through its modular architecture and focus on natural language interaction, Just Chat is positioning itself as a bridge between human creativity and AI capability. It enables users to progress from simple chat interactions to sophisticated AI workflows without requiring specialized knowledge, yet provides the depth necessary for advanced implementations when needed.

This approach aligns well with SingularityNET's mission of developing beneficial AGI that is democratic and inclusive. By removing technical barriers while maintaining advanced capabilities, Just Chat contributes to making AI R&D accessible to everyone, everywhere - a key step toward creating a truly democratic and beneficial artificial intelligence ecosystem.

Needed resources

Social Media and PR: We're looking for members and contributors to help promote the project, spread awareness, manage the community, boost adoption, and gather valuable feedback.

Open Source Licensing

Third-party code that the project uses is under either Apache License 2.0 or MIT, therefore no collisions are present

Links and references

https://github.com/longevity-genie/just-chat 

IBIMA Institute ( https://ibima.med.uni-rostock.de/ )

HEALES organization ( https://www.eha-heales.org/ )

149 /500 chars

tool_tip Additional videos (optional)

Was there any event, initiative or publication that motivated you to register/submit this proposal?

Describe the particulars.

I was informed via email by fellow Longevity activists about the existence of this funding opportunity.