Kheish: multi-actor intelligences that review, validate and format output to produce high quality results

General Introduction

Kheish is an open-source multi-role agent designed for large-scale language modeling (LLM) tasks that require structured, step-by-step collaboration.More than just a simple coordinator, Kheish is an intelligent agent in its own right, requesting modules on demand, integrating user feedback, and switching between specialized roles (e.g., Proposer, Reviewer, Validator, Formatter, etc.), with the ultimately delivering refined results. By utilizing multiple "sub-agents" (roles) within a single framework, Kheish is able to handle tasks such as security audits, document searches, RAG-based exploration, and more.

Function List

• Adaptive role switching: Kheish acts as a single agent with multiple internal roles such as proposer, reviewer, validator and formatter.
• On-demand module request: Kheish can spontaneously invoke modules such as filesystems, shell commands, RAG, SSH, and memory modules.
• Feedback and Iteration: Kheish rechecks and revises his proposals in many assignments, gradually improving the quality of the solutions.
• Retrieval Augmentation Generation (RAG): For large codebases or multi-file contexts, Kheish indexes data into vector storage, reducing token usage and scaling to larger projects.
• Single agent, multitasking: Kheish can handle parallel or serial tasks by defining individual YAML configurations or combining them into a multi-step scenario.

Using Help

Installation process

1. clone warehouse: First, clone Kheish's GitHub repository using Git.

   git clone https://github.com/graniet/kheish.git
   

2. Access to the catalog: Enter the cloned Kheish catalog.

   cd kheish
   

3. Installation of dependencies: Use Cargo to install the required dependencies.

   cargo build
   

Guidelines for use

1. configuration file: Before using Kheish, you need to configure a YAML file to define tasks and roles. The sample configuration file is shown below:

   tasks.
   - name: "Code Audit"
   tasks: name: "Code Audit
   - proposer
   - reviewer
   - validator
   modules: fs
   - fs
   - fs
   

2. Running Tasks: Run Kheish using the configuration file.

   cargo run -- --config path/to/config.yaml
   

3. module call: Kheish can spontaneously invoke modules such as file system (fs), shell commands (sh), RAG (rag), SSH (ssh), and long-term memories (memories) based on task requirements.
4. Feedback and Iteration: During the course of the assignment, Kheish constantly checks and revises his proposal to ensure the accuracy and completeness of the final result.

Functional operation flow

1. Adaptive role switching::
   • Proposer: Generate or update offers based on user input and context.
   • Reviewer: Critically evaluate proposals, identify flaws or request improvements.
   • Validator: Serve as the ultimate gatekeeper to ensure the correctness and completeness of the proposal.
   • Formatter: Convert the validated solution into the final presentation format (e.g. Markdown).
2. On-demand module request::
   • File system (fs): reads files block by block and indexes them into the RAG.
   • Shell commands (sh): run a limited number of shell commands in a sandboxed environment.
   • RAG: Storing and retrieving large amounts of text by embedding, supporting block-based queries.
   • SSH: Secure Remote Command.
   • Memory modules (memories): store or recall data outside of the LLM context (long-term memory).
3. Feedback and Iteration::
   • The sponsor proposes a solution.
   • Reviewers criticize and may request changes.
   • Proponents make improvements based on feedback.
   • The validator eventually approves or requests additional amendments.
4. Retrieval Augmentation Generation (RAG)::
   • For large codebases or multi-file contexts, Kheish indexes the data into a vector store and later retrieves the relevant pieces via semantic queries.
5. Single agent, multitasking::
   • Kheish can handle parallel or serial tasks by defining individual YAML configurations or combining them into a multi-step scenario.