Upload 13 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+agi/assets/AGI.png filter=lfs diff=lfs merge=lfs -text
+agi/assets/ArtificialGeneralIntelligence.pdf filter=lfs diff=lfs merge=lfs -text
+agi/assets/sophos.png filter=lfs diff=lfs merge=lfs -text
+agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,55 @@
----
-license: mit
----
+---
+license: mit
+language:
+- en
+base_model:
+- Qwen/Qwen3-4B-Instruct-2507
+---
+
+# AGI-5
+## Artificial General Intelligence
+
+<img src="agi/assets/AGI.png">
+
+## Overview
+This repository contains an implementation of a modular-agentic architecture for Artificial General Intelligence (AGI). The architecture is designed to facilitate the development of autonomous agents capable of complex reasoning, learning, and interaction with their environment.
+
+## GUI
+
+<img src="agi/assets/GUI.png">
+
+This GUI allows users to interact with the AGI agent through a user-friendly interface. Users can input prompts, view agent responses, and monitor the agent's internal state and tool usage.
+
+# Example
+
+```python
+from agi.sophos import Agent
+from agi.sophos_tools import *
+
+toolbox = all_tools()
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=toolbox,
+)
+
+prompt = "Roll a dice, also whats the weather in Tokyo?"
+response = agent.run(prompt)
+print(response) 
+``` 
+### Output: 
+```python
+
+"""
+You rolled a 4 on a 6-sided die. The weather in Tokyo is sunny with a temperature of 12°C during fall.
+"""
+
+```
+## Research Paper
+
+[Read the research paper](agi/assets/ArtificialGeneralIntelligence.pdf)
+
+This paper delineates a comprehensive architectural framework for the progressive realization of Artificial General Intelligence (AGI), predicated upon a modular-agentic paradigm. We present a system design that integrates sophisticated tool-use capabilities, hierarchical memory management, dynamic code execution, and nascent world-modeling functionalities. The proposed architecture, exemplified through a lightweight `Qwen3-4B-Instruct-2507-Q3_K_S.gguf` model, demonstrates a robust foundation for emergent cognitive properties such as autonomy, recursive self-improvement, and goal-oriented behavior. Furthermore, we explore the theoretical underpinnings of consciousness as an emergent property within complex neural architectures and postulate pathways towards super-intelligence through advanced computational and embodied interaction modalities. The exposition maintains a rigorous academic tone, employing advanced terminology to articulate the intricate conceptual and technical facets of AGI development.
+

agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0ce20058cc0ed6b6c9213bb383589327e458c12ffce0842fc96867042d669c75
+size 1886997600

agi/agent_config.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass
+from typing import List, Dict, Optional
+
+@dataclass
+class AgentConfig:
+    name: str = "Sophos Agent"
+    instructions: str = "You are an AI Agent."
+    model: str = "agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf"
+    max_iterations: int = 99
+    temperature: float = 0.7
+    max_tokens: int = 1050
+    verbose: bool = True
+    enable_memory: bool = False
+    memory_limit: int = 10
+    enable_tools: bool = True
+    allowed_tool_categories: Optional[List[str]] = None
+    sandbox_mode: bool = True
+    require_confirmation: bool = False
+    n_ctx: int = 2048
+    n_gpu_layers: int = 35
+    custom_instructions: str = ""
+    
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "instructions": self.instructions,
+            "model": self.model,
+            "max_iterations": self.max_iterations,
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "verbose": self.verbose,
+            "enable_memory": self.enable_memory,
+            "memory_limit": self.memory_limit,
+            "enable_tools": self.enable_tools,
+            "allowed_tool_categories": self.allowed_tool_categories,
+            "sandbox_mode": self.sandbox_mode,
+            "require_confirmation": self.require_confirmation,
+            "n_ctx": self.n_ctx,
+            "n_gpu_layers": self.n_gpu_layers,
+            "custom_instructions": self.custom_instructions,
+        }
+    
+    @classmethod
+    def from_dict(cls, config_dict: Dict) -> 'AgentConfig':
+        return cls(**config_dict)
+    
+    def get_full_instructions(self) -> str:
+        base = self.instructions
+        if self.custom_instructions:
+            return f"{base}\n\n{self.custom_instructions}"
+        return base
+
+class AgentPresets:
+    @staticmethod
+    def coding_assistant() -> AgentConfig:
+        return AgentConfig(
+            name="Code Assistant",
+            instructions="You are an expert coding assistant. Help with programming tasks, debugging, and code generation.",
+            max_tokens=1500,
+            allowed_tool_categories=["File Operations", "Text Processing", "Utilities"],
+            custom_instructions="Focus on clean, well-documented code."
+        )
+    
+    @staticmethod
+    def data_analyst() -> AgentConfig:
+        return AgentConfig(
+            name="Data Analyst",
+            instructions="You are a data analyst. Help analyze data, perform calculations, and generate insights.",
+            allowed_tool_categories=["Mathematics", "Data Analysis", "Text Processing", "File Operations"]
+        )
+    
+    @staticmethod
+    def general_assistant() -> AgentConfig:
+        return AgentConfig(
+            name="General Assistant",
+            instructions="You are a helpful AI assistant.",
+            allowed_tool_categories=None,
+            enable_memory=True,
+            memory_limit=10
+        )

agi/assets/ArtificialGeneralIntelligence.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fb9e7d571936ff4cf2f36929eceedbfbfc0c88b601d50406a7e527472568549
+size 785625

agi/sophos.py

@@ -0,0 +1,255 @@
+from agi.sophos_models import Sophos
+from agi.sophos_tools import *
+from agi.agent_config import AgentConfig
+from typing import Optional, List, Dict
+import threading
+import time
+import sys
+import json
+
+class AgentMemory:
+    def __init__(self, limit: int = 10):
+        self.limit = limit
+        self.exchanges = []
+    
+    def add_exchange(self, user_message: str, agent_response: str):
+        self.exchanges.append({"user": user_message, "agent": agent_response})
+        if len(self.exchanges) > self.limit:
+            self.exchanges = self.exchanges[-self.limit:]
+    
+    def get_context(self) -> str:
+        if not self.exchanges:
+            return ""
+        context = "\nPrevious conversation:\n"
+        for i, exchange in enumerate(self.exchanges[-3:], 1):
+            context += f"[{i}] User: {exchange['user'][:100]}\nAgent: {exchange['agent'][:100]}\n"
+        return context
+    
+    def clear(self):
+        self.exchanges = []
+    
+    def to_dict(self) -> Dict:
+        return {"exchanges": self.exchanges, "limit": self.limit}
+    
+    def from_dict(self, data: Dict):
+        self.exchanges = data.get("exchanges", [])
+        self.limit = data.get("limit", 10)
+
+class Agent:
+    def __init__(self, name: str = None, instructions: str = None, model: str = None, 
+                 tools: list = None, config: Optional[AgentConfig] = None):
+        if config:
+            self.config = config
+            self.name = config.name
+            self.instructions = config.get_full_instructions()
+            self.model = config.model
+        else:
+            self.config = AgentConfig(
+                name=name or "Sophos Agent",
+                instructions=instructions or "You are an AI Agent.",
+                model=model or "agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf"
+            )
+            self.name = self.config.name
+            self.instructions = self.config.instructions
+            self.model = self.config.model
+        
+        if tools:
+            self.tools = {tool.__name__: tool for tool in tools if hasattr(tool, "_is_tool")}
+        else:
+            self.tools = {}
+        
+        self.memory = None
+        if self.config.enable_memory:
+            self.memory = AgentMemory(limit=self.config.memory_limit)
+        
+        self.sophos = Sophos(
+            model_path=self.model,
+            n_ctx=self.config.n_ctx,
+            n_gpu_layers=self.config.n_gpu_layers
+        )
+
+    def process_tool_calls(self, response_content: str):
+        if "```tool" not in response_content:
+            return None
+            
+        try:
+            tool_results = []
+            parts = response_content.split("```tool")
+            for i in range(1, len(parts)):
+                tool_block = parts[i].split("```")[0].strip()
+                tool_lines = [line.strip() for line in tool_block.split('\n') if line.strip()]
+                
+                for tool_line in tool_lines:
+                    if "(" in tool_line and ")" in tool_line:
+                        tool_name = tool_line.split("(")[0].strip()
+                        arg_part = tool_line.split("(", 1)[1].rsplit(")", 1)[0].strip()
+                        
+                        if tool_name in self.tools:
+                            # Print a red, attention-grabbing message when running a tool
+                            try:
+                                red = "\033[31m"
+                                reset = "\033[0m"
+                                # show the tool invocation in red
+                                print(f"{red}running tool... {tool_name}({arg_part}){reset}")
+                            except Exception:
+                                # fallback to plain print if something odd happens
+                                print(f"running tool... {tool_name}({arg_part})")
+
+                            if not arg_part:
+                                tool_result = self.tools[tool_name]()
+                            else:
+                                try:
+                                    if ',' in arg_part:
+                                        args = eval(f"({arg_part})")
+                                        if isinstance(args, tuple):
+                                            tool_result = self.tools[tool_name](*args)
+                                        else:
+                                            tool_result = self.tools[tool_name](args)
+                                    else:
+                                        parsed_arg = eval(arg_part)
+                                        tool_result = self.tools[tool_name](parsed_arg)
+                                except Exception:
+                                    arg = arg_part.strip('"').strip("'")
+                                    tool_result = self.tools[tool_name](arg)
+                            
+                            tool_results.append(f"{tool_name}: {tool_result}")
+                        else:
+                            tool_results.append(f"Error: Tool {tool_name} not found")
+            
+            return tool_results if tool_results else None
+        except Exception:
+            return None
+        
+    def get_tools_names_and_descriptions(self):
+        return {name: func.__doc__ for name, func in self.tools.items()}
+    
+    def get_stats(self) -> Dict:
+        return {
+            "name": self.name,
+            "model": self.model,
+            "tool_count": len(self.tools),
+            "memory_enabled": self.memory is not None
+        }
+    
+    def save_state(self, filepath: str):
+        state = {
+            "config": self.config.to_dict(),
+            "memory": self.memory.to_dict() if self.memory else None
+        }
+        with open(filepath, 'w') as f:
+            json.dump(state, f, indent=2)
+        return f"State saved to {filepath}"
+    
+    def load_state(self, filepath: str):
+        with open(filepath, 'r') as f:
+            state = json.load(f)
+        if state.get("memory") and self.memory:
+            self.memory.from_dict(state["memory"])
+        return f"State loaded from {filepath}"
+    
+    def add_tools(self, tools: List):
+        for tool in tools:
+            if hasattr(tool, "_is_tool"):
+                self.tools[tool.__name__] = tool
+        return f"Added {len(tools)} tools"
+    
+    def remove_tool(self, tool_name: str):
+        if tool_name in self.tools:
+            del self.tools[tool_name]
+            return f"Tool {tool_name} removed"
+        return f"Tool {tool_name} not found"
+    
+    def list_tools(self) -> List[str]:
+        return list(self.tools.keys())
+
+    def run(self, prompt: str):
+        if getattr(self.config, 'verbose', False):
+            print(f"Running Agent: {self.name}, Model: {self.model}, Tools: {len(self.tools)}, Memory Enabled: {self.memory is not None}, prompt: {prompt[:50]}...")
+        memory_context = ""
+        if self.memory:
+            memory_context = self.memory.get_context()
+        
+        system_prompt = f"""You are {self.name}. {self.instructions}
+
+Tools: {self.get_tools_names_and_descriptions()}
+
+Use tools in this format:
+```tool
+tool_name(arg)
+```
+
+WORKFLOW:
+1. Use tools if needed for live info
+2. Provide final response WITHOUT tool calls after getting results
+3. Don't repeat tool calls
+{memory_context}
+
+user: {prompt}"""
+
+        messages = [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": prompt}
+        ]
+
+        max_iterations = self.config.max_iterations
+        iteration = 0
+        last_tool_calls = []
+        final_response = None
+        
+        while iteration < max_iterations:
+            iteration += 1
+
+            # show a simple "Thinking...." spinner while the model is generating
+            stop_event = threading.Event()
+
+            def _spinner(e: threading.Event):
+                dots = 0
+                try:
+                    while not e.is_set():
+                        print("\rThinking" + "." * (dots % 4) + "   ", end="", flush=True)
+                        dots += 1
+                        time.sleep(0.5)
+                except Exception:
+                    pass
+                # clear the line when done
+                try:
+                    print("\r" + " " * 40 + "\r", end="", flush=True)
+                except Exception:
+                    pass
+
+            spinner_thread = threading.Thread(target=_spinner, args=(stop_event,), daemon=True)
+            spinner_thread.start()
+            try:
+                response = self.sophos.ask(str(messages), 
+                                          max_tokens=self.config.max_tokens,
+                                          temperature=self.config.temperature)
+            finally:
+                stop_event.set()
+                spinner_thread.join(timeout=0.2)
+
+            current_response = response 
+            tool_results = self.process_tool_calls(current_response)
+            
+            if tool_results is None:
+                final_response = current_response
+                break
+        
+            all_results = "\n".join(tool_results)
+            current_tool_calls = [result.split(":")[0] for result in tool_results]
+            
+            if current_tool_calls == last_tool_calls and iteration > 1:
+                messages.append({"role": "assistant", "content": current_response})
+                messages.append({"role": "user", "content": f"Results:\n{all_results}\n\nProvide final answer without more tools."})
+            else:
+                messages.append({"role": "assistant", "content": current_response})
+                messages.append({"role": "user", "content": f"Results:\n{all_results}\n\nProvide final response."})
+            
+            last_tool_calls = current_tool_calls
+        
+        if iteration >= max_iterations:
+            final_response = current_response
+        
+        if self.memory and final_response:
+            self.memory.add_exchange(prompt, final_response)
+        
+        return final_response or current_response

agi/sophos_models.py

@@ -0,0 +1,33 @@
+import contextlib
+import os
+from llama_cpp import Llama
+
+
+class Sophos:
+    def __init__(self, model_path="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf", n_ctx=2048, n_gpu_layers=35):
+        """Initialize the Llama model while suppressing any noisy stdout/stderr from the underlying library."""
+        self.model_path = model_path
+        self.n_ctx = n_ctx
+        self.n_gpu_layers = n_gpu_layers
+        # suppress any prints coming from llama_cpp during initialization
+        with open(os.devnull, 'w') as devnull:
+            with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
+                self.model = Llama(model_path=model_path, n_ctx=n_ctx, n_gpu_layers=n_gpu_layers)
+
+    def ask(self, prompt, max_tokens=1050, temperature=0.7):
+        """Call the model while suppressing any noisy stdout/stderr from the underlying library."""
+        messages = [{"role": "user", "content": prompt}]
+        # suppress any prints coming from llama_cpp while creating completion
+        with open(os.devnull, 'w') as devnull:
+            with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
+                output = self.model.create_chat_completion(messages, max_tokens=max_tokens, temperature=temperature)
+
+        return output["choices"][0]["message"]["content"]
+
+if __name__ == "__main__":
+    sophos = Sophos()
+    while True:
+        prompt = input("\nPrompt: ")
+        if prompt.lower() in ['exit', 'quit', 'q']:
+            break
+        print(sophos.ask(prompt))

agi/sophos_tools.py

@@ -0,0 +1,278 @@
+import datetime
+import random
+import string
+import math
+import os
+import base64
+import hashlib
+import time
+import json
+import re
+from typing import List
+
+def function_tool(func):
+    func._is_tool = True
+    return func
+
+@function_tool
+def get_weather(city: str) -> str:
+    '''fetches weather information for a given city.'''
+    month = datetime.datetime.now().month
+    season_temps = {(12, 1, 2): ("winter", 2), (3, 4, 5): ("spring", 15), (6, 7, 8): ("summer", 28)}
+    season, base = next((v for k, v in season_temps.items() if month in k), ("fall", 12))
+    return f"Weather in {city}: sunny, {base + random.randint(-5, 5)}°C, {season}"
+
+@function_tool
+def get_time() -> str:
+    '''fetches the current time.'''
+    return f"Current time: {datetime.datetime.now().strftime('%H:%M:%S')}"
+
+@function_tool
+def get_date() -> str:
+    '''fetches the current date.'''
+    return f"Date: {datetime.datetime.now().strftime('%Y-%m-%d')}"
+
+@function_tool
+def get_day() -> str:
+    '''fetches the current day of the week.'''
+    return f"Today is {datetime.datetime.now().strftime('%A')}"
+
+@function_tool
+def calculate(expression: str) -> str:
+    '''performs basic arithmetic calculations.'''
+    try:
+        return f"{expression} = {eval(expression, {'__builtins__': None}, {})}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def generate_password(length: int = 12) -> str:
+    '''Generates a random password of specified length.'''
+    if length < 8:
+        return "Error: min 8 chars"
+    return f"Password: {''.join(random.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(length))}"
+
+@function_tool
+def convert_temperature(value: float, from_unit: str, to_unit: str) -> str:
+    '''Converts temperature between Celsius, Fahrenheit, and Kelvin.'''
+    conversions = {
+        ('celsius', 'fahrenheit'): lambda v: (v * 9/5) + 32,
+        ('celsius', 'kelvin'): lambda v: v + 273.15,
+        ('fahrenheit', 'celsius'): lambda v: (v - 32) * 5/9,
+        ('fahrenheit', 'kelvin'): lambda v: (v - 32) * 5/9 + 273.15,
+        ('kelvin', 'celsius'): lambda v: v - 273.15,
+        ('kelvin', 'fahrenheit'): lambda v: (v - 273.15) * 9/5 + 32
+    }
+    key = (from_unit.lower(), to_unit.lower())
+    return f"{value}° {from_unit} = {conversions[key](value):.2f}° {to_unit}" if key in conversions else "Error: invalid units"
+
+@function_tool
+def roll_dice(sides: int, rolls: int = 1) -> str:
+    '''Rolls a dice with specified sides a given number of times.'''
+    results = [random.randint(1, sides) for _ in range(rolls)]
+    return f"{rolls}d{sides}: {results}, Total: {sum(results)}"
+
+@function_tool
+def word_count(text: str) -> str:
+    '''Counts the number of words in the given text.'''
+    return f"Words: {len(text.split())}"
+
+@function_tool
+def get_factorial(number: int) -> str:
+    '''Calculates the factorial of a given number.'''
+    try:
+        return f"{number}! = {math.factorial(number)}"
+    except:
+        return "Error: invalid input"
+
+@function_tool
+def list_sort(numbers: List[float], ascending: bool = True) -> str:
+    '''Sorts a list of numbers in ascending or descending order.'''
+    return f"Sorted: {sorted(numbers, reverse=not ascending)}"
+
+@function_tool
+def generate_uuid() -> str:
+    '''Generates a random UUID.'''
+    import uuid
+    return f"UUID: {uuid.uuid4()}"
+
+@function_tool
+def save_file(file_path: str, content: str) -> str:
+    '''Saves content to a specified file path. use as save_file("filename.extension", "content") .for new lines use \\n'''
+    folder = "agi/sandbox/agent_sandbox/"
+    os.makedirs(folder, exist_ok=True)
+    try:
+        with open(folder + file_path, 'w') as f:
+            f.write(content)
+        return f"Saved to {folder + file_path}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def read_file(file_path: str) -> str:
+    '''Reads content from a specified file path in the sandbox.'''
+    try:
+        with open("agi/sandbox/agent_sandbox/" + file_path, 'r') as f:
+            return f"Content:\n{f.read()}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def list_files() -> str:
+    '''Lists all files in the agent sandbox directory.'''
+    folder = "agi/sandbox/agent_sandbox/"
+    return f"Files: {', '.join(os.listdir(folder))}" if os.path.exists(folder) and os.listdir(folder) else "Empty"
+
+@function_tool
+def delete_file(file_path: str) -> str:
+    '''Deletes a file from the agent sandbox.'''
+    try:
+        os.remove("agi/sandbox/agent_sandbox/" + file_path)
+        return f"Deleted {file_path}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def append_to_file(file_path: str, content: str) -> str:
+    '''Appends content to an existing file in the sandbox.'''
+    folder = "agi/sandbox/agent_sandbox/"
+    os.makedirs(folder, exist_ok=True)
+    try:
+        with open(folder + file_path, 'a') as f:
+            f.write(content)
+        return f"Appended to {file_path}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def search_text(text: str, pattern: str) -> str:
+    '''Searches for a pattern in text and returns matches.'''
+    matches = re.findall(pattern, text, re.IGNORECASE)
+    return f"Found {len(matches)} matches: {matches[:10]}" if matches else f"No matches for: {pattern}"
+
+@function_tool
+def replace_text(text: str, old: str, new: str) -> str:
+    '''Replaces occurrences of old text with new text.'''
+    return f"Replaced {text.count(old)} occurrences: {text.replace(old, new)}"
+
+@function_tool
+def encode_base64(text: str) -> str:
+    '''Encodes text to base64.'''
+    return f"Base64: {base64.b64encode(text.encode()).decode()}"
+
+@function_tool
+def decode_base64(encoded: str) -> str:
+    '''Decodes base64 text.'''
+    try:
+        return f"Decoded: {base64.b64decode(encoded.encode()).decode()}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def hash_text(text: str, algorithm: str = "sha256") -> str:
+    '''Generates hash of text using specified algorithm (md5, sha1, sha256, sha512).'''
+    algos = {"md5": hashlib.md5, "sha1": hashlib.sha1, "sha256": hashlib.sha256, "sha512": hashlib.sha512}
+    return f"{algorithm}: {algos[algorithm](text.encode()).hexdigest()}" if algorithm in algos else "Error: invalid algorithm"
+
+@function_tool
+def generate_random_number(min_val: int, max_val: int) -> str:
+    '''Generates a random number between min and max values.'''
+    return f"Random: {random.randint(min_val, max_val)}"
+
+@function_tool
+def get_list_statistics(numbers: List[float]) -> str:
+    '''Calculates statistics (mean, median, min, max, sum) for a list of numbers.'''
+    import statistics
+    return f"Mean: {statistics.mean(numbers):.2f}, Median: {statistics.median(numbers):.2f}, Min: {min(numbers)}, Max: {max(numbers)}, Sum: {sum(numbers)}"
+
+@function_tool
+def reverse_text(text: str) -> str:
+    '''Reverses the given text.'''
+    return f"Reversed: {text[::-1]}"
+
+@function_tool
+def to_uppercase(text: str) -> str:
+    '''Converts text to uppercase.'''
+    return f"Uppercase: {text.upper()}"
+
+@function_tool
+def to_lowercase(text: str) -> str:
+    '''Converts text to lowercase.'''
+    return f"Lowercase: {text.lower()}"
+
+@function_tool
+def count_characters(text: str, include_spaces: bool = True) -> str:
+    '''Counts characters in text.'''
+    count = len(text) if include_spaces else len(text.replace(" ", ""))
+    return f"Chars: {count}"
+
+@function_tool
+def json_format(data: str) -> str:
+    '''Formats a JSON string with proper indentation.'''
+    try:
+        return f"JSON:\n{json.dumps(json.loads(data), indent=2)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def get_timestamp() -> str:
+    '''Returns current Unix timestamp.'''
+    return f"Timestamp: {int(time.time())}"
+
+@function_tool
+def convert_timestamp(timestamp: int) -> str:
+    '''Converts Unix timestamp to readable date/time.'''
+    return f"{timestamp} = {datetime.datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')}"
+
+@function_tool
+def calculate_age(birth_year: int) -> str:
+    '''Calculates age based on birth year.'''
+    return f"Age: {datetime.datetime.now().year - birth_year} years"
+
+@function_tool
+def days_until(target_date: str) -> str:
+    '''Calculates days until a target date (format: YYYY-MM-DD).'''
+    try:
+        delta = datetime.datetime.strptime(target_date, "%Y-%m-%d") - datetime.datetime.now()
+        return f"Days until {target_date}: {delta.days}"
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+@function_tool
+def create_acronym(phrase: str) -> str:
+    '''Creates an acronym from a phrase.'''
+    return f"Acronym: {''.join([w[0].upper() for w in phrase.split() if w])}"
+
+@function_tool
+def fibonacci(n: int) -> str:
+    '''Generates Fibonacci sequence up to n terms.'''
+    if n <= 0 or n > 50:
+        return "Error: n must be 1-50"
+    fib = [0, 1]
+    for i in range(2, n):
+        fib.append(fib[i-1] + fib[i-2])
+    return f"Fibonacci({n}): {fib[:n]}"
+
+@function_tool
+def is_prime(number: int) -> str:
+    '''Checks if a number is prime.'''
+    if number < 2:
+        return f"{number} is not prime"
+    for i in range(2, int(number ** 0.5) + 1):
+        if number % i == 0:
+            return f"{number} is not prime"
+    return f"{number} is prime"
+
+@function_tool
+def gcd(a: int, b: int) -> str:
+    '''Calculates the greatest common divisor of two numbers.'''
+    return f"GCD({a}, {b}) = {math.gcd(a, b)}"
+
+@function_tool
+def lcm(a: int, b: int) -> str:
+    '''Calculates the least common multiple of two numbers.'''
+    return f"LCM({a}, {b}) = {abs(a * b) // math.gcd(a, b)}"
+
+def all_tools():
+    """Returns a list of all functions decorated with @function_tool."""
+    return [obj for obj in globals().values() if callable(obj) and hasattr(obj, '_is_tool') and obj._is_tool]

agi/tool_categories.py

@@ -0,0 +1,69 @@
+from agi.sophos_tools import *
+from typing import List, Dict
+
+class ToolCategory:
+    def __init__(self, name: str, description: str, tools: List):
+        self.name = name
+        self.description = description
+        self.tools = tools
+    
+    def get_tools(self):
+        return self.tools
+    
+    def __repr__(self):
+        return f"ToolCategory('{self.name}', {len(self.tools)} tools)"
+
+TIME_TOOLS = ToolCategory("Time & Date", "Time and date tools",
+    [get_time, get_date, get_day, get_timestamp, convert_timestamp, calculate_age, days_until])
+
+MATH_TOOLS = ToolCategory("Mathematics", "Math operations",
+    [calculate, get_factorial, fibonacci, is_prime, gcd, lcm, generate_random_number, roll_dice])
+
+FILE_TOOLS = ToolCategory("File Operations", "File management in sandbox",
+    [save_file, read_file, list_files, delete_file, append_to_file])
+
+TEXT_TOOLS = ToolCategory("Text Processing", "Text manipulation",
+    [word_count, reverse_text, to_uppercase, to_lowercase, count_characters, search_text, replace_text, create_acronym])
+
+DATA_TOOLS = ToolCategory("Data Analysis", "Data processing",
+    [list_sort, get_list_statistics])
+
+ENCODING_TOOLS = ToolCategory("Encoding & Hashing", "Encoding and hashing",
+    [encode_base64, decode_base64, hash_text])
+
+UTILITY_TOOLS = ToolCategory("Utilities", "General utilities",
+    [get_weather, generate_password, convert_temperature, generate_uuid, json_format])
+
+ALL_CATEGORIES = [TIME_TOOLS, MATH_TOOLS, FILE_TOOLS, TEXT_TOOLS, DATA_TOOLS, ENCODING_TOOLS, UTILITY_TOOLS]
+
+def get_tools_by_category(category_name: str) -> List:
+    for category in ALL_CATEGORIES:
+        if category.name.lower() == category_name.lower():
+            return category.get_tools()
+    return []
+
+def get_tools_by_categories(category_names: List[str]) -> List:
+    tools = []
+    for name in category_names:
+        tools.extend(get_tools_by_category(name))
+    return tools
+
+def get_all_categorized_tools() -> List:
+    tools = []
+    for category in ALL_CATEGORIES:
+        tools.extend(category.get_tools())
+    return tools
+
+def list_categories() -> Dict[str, str]:
+    return {cat.name: cat.description for cat in ALL_CATEGORIES}
+
+def get_category_info(category_name: str) -> Dict:
+    for category in ALL_CATEGORIES:
+        if category.name.lower() == category_name.lower():
+            return {
+                "name": category.name,
+                "description": category.description,
+                "tool_count": len(category.tools),
+                "tools": [tool.__name__ for tool in category.tools]
+            }
+    return {}

agi_gui.py

@@ -0,0 +1,206 @@
+
+"""
+Simple chat GUI for the project using customtkinter.
+
+Features:
+- Chat history area
+- Input field + Send button
+- Clear history button
+- Status label to show when the agent is thinking
+- Uses a background thread to call agent.run so the UI stays responsive
+
+Usage: python agi_gui.py
+
+This file expects the project-local Agent and AgentConfig to exist at
+`agi.sophos` and `agi.agent_config`, and `all_tools` at `agi.sophos_tools`.
+If `customtkinter` is not installed, the UI will show a helpful error.
+"""
+
+import threading
+import queue
+import time
+import traceback
+try:
+	import customtkinter as ctk
+except Exception:
+	ctk = None
+
+from datetime import datetime
+
+if ctk:
+	ctk.set_appearance_mode("System")
+	ctk.set_default_color_theme("blue")
+
+
+def format_message(role: str, text: str) -> str:
+	ts = datetime.now().strftime("%H:%M:%S")
+	return f"[{ts}] {role}: {text}\n\n"
+
+
+class AGIChatApp:
+	def __init__(self, root):
+		self.root = root
+		self.root.title("AGI Chat")
+		self.root.geometry("800x600")
+
+		# message queue for thread -> UI communication
+		self._q = queue.Queue()
+
+		# top frame: history
+		self.history = ctk.CTkTextbox(master=root, width=760, height=420)
+		self.history.configure(state="disabled")
+		self.history.pack(padx=20, pady=(20, 6))
+
+		# status and controls
+		ctrl_frame = ctk.CTkFrame(master=root)
+		ctrl_frame.pack(fill="x", padx=20, pady=(0, 6))
+
+		self.status_label = ctk.CTkLabel(master=ctrl_frame, text="Ready")
+		self.status_label.pack(side="left", padx=(8, 6))
+
+		clear_btn = ctk.CTkButton(master=ctrl_frame, text="Clear", width=80, command=self.clear_history)
+		clear_btn.pack(side="right", padx=(6, 8))
+
+		# bottom frame: entry and send
+		bottom = ctk.CTkFrame(master=root)
+		bottom.pack(fill="x", padx=20, pady=(0, 20))
+
+		self.entry = ctk.CTkEntry(master=bottom, placeholder_text="Type your message here...")
+		self.entry.pack(side="left", fill="x", expand=True, padx=(6, 6), pady=6)
+		self.entry.bind("<Return>", self._on_enter)
+
+		send_btn = ctk.CTkButton(master=bottom, text="Send", width=120, command=self.on_send)
+		send_btn.pack(side="right", padx=(6, 6), pady=6)
+
+		# Agent will be lazy-initialized on first send to avoid long startup at UI open
+		self.agent = None
+		self.agent_lock = threading.Lock()
+
+		# periodically poll the queue for results from worker threads
+		self.root.after(100, self._poll_queue)
+
+	def _append_history(self, text: str):
+		self.history.configure(state="normal")
+		self.history.insert("end", text)
+		self.history.see("end")
+		self.history.configure(state="disabled")
+
+	def clear_history(self):
+		self.history.configure(state="normal")
+		self.history.delete("0.0", "end")
+		self.history.configure(state="disabled")
+		self.status_label.configure(text="Cleared")
+
+	def _on_enter(self, event):
+		# prevent the default newline insertion
+		self.on_send()
+		return "break"
+
+	def on_send(self):
+		user_text = self.entry.get().strip()
+		if not user_text:
+			return
+		self.entry.delete(0, "end")
+		self._append_history(format_message("User", user_text))
+		self.status_label.configure(text="Thinking...")
+
+		# start background thread to call agent
+		t = threading.Thread(target=self._background_agent_call, args=(user_text,), daemon=True)
+		t.start()
+
+	def _init_agent(self):
+		# only run import and initialization once, in guarded block
+		if self.agent is not None:
+			return
+		try:
+			# local project imports
+			from agi.sophos import Agent
+			from agi.agent_config import AgentConfig
+			from agi.sophos_tools import all_tools
+
+			config = AgentConfig(
+				name="Sophos-GUI",
+				instructions="You are an AI agent.",
+				max_iterations=30,
+				max_tokens=1500,
+				temperature=0.7,
+				verbose=False,
+				enable_memory=True,
+				memory_limit=5,
+			)
+
+			toolbox = all_tools()
+			# instantiate Agent
+			self.agent = Agent(config=config, tools=toolbox)
+			self._append_history(format_message("System", "Agent initialized."))
+		except Exception as e:
+			tb = traceback.format_exc()
+			self._append_history(format_message("Error", f"Failed to initialize agent: {e}\n{tb}"))
+			self.status_label.configure(text="Agent init failed")
+
+	def _background_agent_call(self, prompt: str):
+		# ensure agent is ready
+		with self.agent_lock:
+			if self.agent is None:
+				self._init_agent()
+
+		if self.agent is None:
+			# initialization failed
+			self._q.put(("error", "Agent not available"))
+			return
+
+		try:
+			start = time.time()
+			# call agent.run which may be blocking
+			resp = self.agent.run(prompt)
+			elapsed = time.time() - start
+			self._q.put(("response", resp, elapsed))
+		except Exception as e:
+			tb = traceback.format_exc()
+			self._q.put(("error", f"{e}\n{tb}"))
+
+	def _poll_queue(self):
+		try:
+			while True:
+				item = self._q.get_nowait()
+				if not item:
+					continue
+				kind = item[0]
+				if kind == "response":
+					_, resp, elapsed = item
+					self._append_history(format_message("Agent", resp))
+					self.status_label.configure(text=f"Done ({elapsed:.1f}s)")
+				elif kind == "error":
+					_, err = item
+					self._append_history(format_message("Error", str(err)))
+					self.status_label.configure(text="Error")
+				else:
+					# unknown message
+					self._append_history(format_message("Debug", str(item)))
+		except queue.Empty:
+			pass
+		finally:
+			self.root.after(100, self._poll_queue)
+
+
+def main():
+	if ctk is None:
+		print("customtkinter is not installed. Install it with: pip install customtkinter")
+		# Fallback to a basic tkinter popup that informs the user
+		try:
+			import tkinter as tk
+			from tkinter import messagebox
+			root = tk.Tk()
+			root.withdraw()
+			messagebox.showerror("Missing dependency", "customtkinter is not installed.\nRun: pip install customtkinter")
+		except Exception:
+			pass
+		return
+
+	root = ctk.CTk()
+	app = AGIChatApp(root)
+	root.mainloop()
+
+
+if __name__ == "__main__":
+	main()

main.py

@@ -0,0 +1,20 @@
+from agi.sophos import Agent
+from agi.sophos_tools import all_tools, function_tool   
+from agi.agent_config import AgentConfig
+
+config = AgentConfig(
+    name="Sophos",
+    instructions="You are an AI agent.",
+    max_iterations=30,
+    max_tokens=1500,
+    temperature=0.7,
+    verbose=True,
+    enable_memory=True,
+    memory_limit=5
+)
+
+toolbox = all_tools()
+agent = Agent(config=config, tools=toolbox)
+
+response = agent.run("roll a dice. also whats the weather like today? then write a short poem about it.")
+print("\nAgent response:\n", response)

simple_test.py

@@ -0,0 +1,15 @@
+from agi.sophos import Agent
+from agi.sophos_tools import *
+
+toolbox = all_tools()
+
+agent = Agent(
+    name="Sophos Agent",
+    instructions="You are an AI Agent.",
+    model="agi/Qwen3-4B-Instruct-2507-Q3_K_S.gguf",
+    tools=toolbox,
+)
+
+prompt = "Roll a dice, also whats the weather in Tokyo?"
+response = agent.run(prompt)
+print(response)