◈ GARVIS

Governed Artificial Intelligence for Human-Directed Creation

Created and directed by Adrien D. Thomas
ProCityHub · Treaty 6 Territory · Edmonton, Alberta, Canada

Intelligence should expand human possibility—not erase human authority.

What Is GARVIS?

GARVIS is a governed AI systems platform built to help a human research, reason, create, test, organize, and act without surrendering control.

It combines:

AI agents and tool orchestration
Local and cloud-assisted reasoning
Persistent and bounded memory
Capability-aware execution
Evidence and provenance tracking
Deterministic Lattice processing
Human approval gates
Security and privacy controls
Reproducible testing
The HyperCube Heartbeat reasoning cycle
A long-term path toward a complete personal AI interface

GARVIS is not designed to be an unaccountable machine that silently takes control.

It is designed to become a trusted intelligence system that can say:

I UNDERSTAND THE OBJECTIVE.
I CAN EXPLAIN THE EVIDENCE.
I CAN SHOW THE PLAN.
I KNOW MY PERMISSIONS.
I WILL STOP WHEN APPROVAL IS REQUIRED.

The Vision

Most AI systems are built around a single question:

What can the model do?

GARVIS begins with a different question:

What should the system be allowed to do, under what evidence, for whose benefit, and with whose approval?

The goal is an AI environment where intelligence is:

Powerful but governed
Creative but accountable
Persistent but privacy-aware
Autonomous within defined boundaries
Honest about uncertainty
Capable of learning without rewriting its own authority
Useful in the real world
Loyal to the human-defined mission

GARVIS is intended to grow from a command-line runtime into a complete, reversible, human-controlled AI environment spanning research, software, documents, voice, memory, simulations, business systems, mobile interfaces, and specialized agent teams.

Why GARVIS Exists

AI is becoming capable of reasoning across code, documents, tools, accounts, communication systems, and physical devices.

That creates enormous opportunity—and enormous responsibility.

GARVIS exists to explore a future where AI can help people:

Understand complex information
Build software
Preserve evidence
Generate and test ideas
Coordinate specialized agents
Discover legitimate work and business opportunities
Create applications and digital products
Maintain long-term project memory
Detect contradictions and unsupported claims
Prepare decisions without secretly making them
Operate locally when privacy matters
Use cloud intelligence only when intentionally enabled

The purpose is not automation for its own sake.

The purpose is human amplification with visible boundaries.

System Architecture

┌──────────────────────────────────────────────────────────────┐
│                         HUMAN AUTHORITY                       │
│                     ADRIEN D. THOMAS                          │
└──────────────────────────────┬───────────────────────────────┘
                               │ approval · intent · values
                               ▼
┌──────────────────────────────────────────────────────────────┐
│                         THUNDERBIRD                           │
│       Public interface · voice · dashboards · approvals      │
└──────────────────────────────┬───────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│                            GARVIS                            │
│   Agents · tools · memory · capabilities · security · logs   │
└───────────────┬───────────────────────┬──────────────────────┘
                │                       │
                ▼                       ▼
┌──────────────────────────┐  ┌───────────────────────────────┐
│   HYPERCUBE HEARTBEAT    │  │        MODEL RUNTIMES         │
│ observe · verify · learn │  │ local-first · OpenAI optional │
└───────────────┬──────────┘  └───────────────────────────────┘
                │
                ▼
┌──────────────────────────────────────────────────────────────┐
│              TOOLS · RESEARCH · CODE · APPLICATIONS          │
└──────────────────────────────────────────────────────────────┘

Core layers

Layer	Responsibility
Thunderbird	Public interface, dashboards, voice, navigation, and approval controls
GARVIS	Agent runtime, tools, memory, security, capabilities, and coordination
HyperCube Heartbeat	Observation, verification, simulation, planning, learning, and consolidation
Lattice Research	Deterministic structures, measurable state, hypotheses, and experimental processing
OpenAI	Approved cloud-reasoning direction when remote intelligence is intentionally enabled
Kaggle	Reproducible notebooks, datasets, benchmarks, and public validation
ProCityHub	Project organization and public development record

Capability Is Not Authorization

This is the central operating law of GARVIS:

CAPABILITY IS NOT AUTHORIZATION

A tool may exist.

An agent may understand how to use it.

A model may propose an action.

None of those facts automatically grant permission.

Protected actions require explicit approval from Adrien D. Thomas at the appropriate stage.

Actions requiring approval

Publishing
Sending messages
Applying for jobs or contracts
Accepting agreements
Spending money
Purchasing products or services
Changing accounts or integrations
Installing software
Modifying protected systems
Committing protected changes
Pushing branches
Creating or modifying pull requests
Merging
Deploying
Deleting data
Broadcasting over real networks
Disclosing confidential information

GARVIS may prepare the work, explain the consequences, test the proposal, and present an approval packet.

It must not convert technical ability into self-issued authority.

Governed Development Pipeline

Every significant GARVIS capability follows this path:

RESEARCH
    ↓
SPECIFICATION
    ↓
PROTOTYPE
    ↓
TESTS
    ↓
SECURITY REVIEW
    ↓
PULL REQUEST
    ↓
ADRIEN APPROVAL
    ↓
MERGE
    ↓
DEPLOYMENT APPROVAL

Approval at one stage does not automatically approve the next.

For example:

APPROVED_TO_PROTOTYPE ≠ APPROVED_TO_COMMIT
APPROVED_TO_COMMIT    ≠ APPROVED_TO_PUSH
APPROVED_TO_PUSH      ≠ APPROVED_TO_MERGE
APPROVED_TO_MERGE     ≠ APPROVED_TO_DEPLOY

This keeps development traceable, reversible, and understandable.

HyperCube Heartbeat

The HyperCube Heartbeat is GARVIS’s recurring reasoning and learning cycle.

RECEIVE
→ ORIENT
→ SEGMENT
→ OBSERVE
→ PREDICT
→ VERIFY
→ IMAGINE
→ VALUE-SCORE
→ PLAN
→ COLLABORATE
→ CREATE
→ TEST
→ REVIEW
→ OUTPUT
→ REST
→ DREAM
→ LEARN
→ CONSOLIDATE
→ HEARTBEAT AGAIN

The Heartbeat is intended to prevent a system from jumping directly from input to action.

It encourages GARVIS to:

Understand the request
Separate the problem into parts
Identify evidence and uncertainty
Compare alternatives
Test assumptions
Recognize approval boundaries
Produce a reviewable result
Learn from the outcome
Preserve useful knowledge
Begin the next cycle with greater coherence

Evidence Before Certainty

GARVIS does not treat every generated sentence as truth.

Information can be classified as:

VERIFIED_BY_PRIMARY_RECORD
SUPPORTED_BY_MULTIPLE_RECORDS
MEASURED_RESULT
MATHEMATICAL_DERIVATION
USER_DECLARATION
PUBLIC_PLATFORM_STATEMENT
TECHNICAL_INFERENCE
RESEARCH_HYPOTHESIS
BUSINESS_ESTIMATE
CREATIVE_IDEATION
UNVERIFIED_LEAD
CONTRADICTED
SUPERSEDED
RETRACTED
UNKNOWN

This distinction matters.

A model output is not independent evidence.
A visualization is not proof.
A numerical coincidence is not proof.
A confident tone is not proof.
A repeated claim is not additional evidence.

GARVIS aims to preserve both positive and negative findings so the research record remains honest.

Local First, Cloud by Choice

GARVIS is being developed around a local-first operating philosophy.

LOCAL WHEN POSSIBLE
CLOUD WHEN USEFUL
HUMAN APPROVAL WHEN REQUIRED

Local operation can provide:

Greater privacy
Reduced dependence on external services
Offline experimentation
More control over memory and files
Predictable capability boundaries

Cloud reasoning can provide:

Stronger general reasoning
Access to approved OpenAI models
Larger-context analysis
Advanced tool and agent workflows

Cloud access is intentional—not assumed.

Credentials must be stored locally and must never be committed to the repository or pasted into public conversations.

Current Capabilities

GARVIS is an active research and engineering project. The repository currently includes operational, experimental, and planned components.

Capability	Status
Python package and command-line interface	Active
Local-first conversation runtime	Active / configuration required
Explicit remote-model mode	Active / credentials required
Persistent session memory	Active
Memory lifecycle commands	Active
Core-memory commands	Active
Capability inspection and brokerage	Active
Human-review response handling	Active
Deterministic Lattice-cycle processing	Active
JSON evidence input for Lattice cycles	Active
Agent and tool framework	Active
Evidence-envelope components	Active / evolving
Security and governance documentation	Active
Automated tests, linting, formatting, and type checks	Active
Thunderbird graphical interface	Planned
Full Android phone integration	Long-term development goal
Default launcher and voice-assistant role	Long-term development goal
Fully autonomous general intelligence	Research goal—not an established claim

Command-Line Interfaces

The project exposes several command-line entry points:

garvis
garvis-local
garvis-memory
garvis-capabilities
garvis-core-memory

Main runtime

garvis --help

Start an interactive local session:

garvis

Send a single prompt:

garvis "Summarize the current project state."

Use a named session:

garvis --session research-session

Use a specific SQLite memory database:

garvis --db ./data/garvis-memory.db

Disable persistent memory for one run:

garvis --no-memory "Analyze this without storing the conversation."

Deterministic Lattice cycle

Run a Lattice cycle from an explicit JSON evidence file:

garvis --lattice-cycle evidence.json --cycle 1

Evaluate a proposal as an external action:

garvis \
  --lattice-cycle evidence.json \
  --cycle 2 \
  --external-action

The external-action flag requests human review. It does not perform the proposed external action.

Remote reasoning

Remote reasoning must be explicitly requested:

garvis --remote "Analyze the architecture."

Store the required API credential locally:

export OPENAI_API_KEY="<SECRET_STORED_LOCALLY>"

Never place a real API key inside the README, source code, issue tracker, screenshots, or chat transcript.

Installation

Requirements

Python 3.9 or newer
Git
uv recommended
A configured local model for local-language generation
An OpenAI API key only when approved remote reasoning is used

Clone the repository

git clone https://github.com/ProCityHub/GARVIS.git
cd GARVIS

Install with `uv`

uv sync --all-extras --all-packages --group dev

Confirm the CLI

uv run garvis --help

Run the project checks

make check

The full check target includes:

FORMAT CHECK
→ RUFF LINT
→ MYPY
→ PYTEST

Run tests alone:

make tests

Run coverage:

make coverage

Python Example

from garvis import GarvisAssistant, assess_request

assessment = assess_request(
    "Prepare a deployment plan, but do not deploy anything."
)

print("Approval requirement:", assessment.approval_requirement)

assistant = GarvisAssistant()
reply = assistant.respond(
    "Explain the safest next step for this request."
)

print(reply)

The exact runtime configuration may evolve as GARVIS continues through staged development.

Repository Structure

The repository contains both the upstream agent framework foundation and ProCityHub’s GARVIS extensions.

GARVIS/
├── src/
│   ├── agents/              # Agent SDK foundation
│   └── garvis/              # GARVIS runtime and research components
├── tests/                   # Automated tests
├── docs/                    # Documentation and governance records
├── examples/                # Usage patterns and experiments
├── .github/                 # Workflows and repository automation
├── AGENTS.md                # Agent operating instructions
├── GOVERNED_FILES.txt       # Files requiring controlled handling
├── FROZEN_FILES.txt         # Protected historical records
├── RETRACTIONS.md           # Corrected or withdrawn claims
├── pyproject.toml           # Package and tool configuration
├── Makefile                 # Development commands
└── README.md                # Public project front face

Some experimental and legacy components remain under review. Their presence in the repository does not mean they are approved for production use.

Security Model

GARVIS follows several non-negotiable rules:

NO SECRET KEYS IN SOURCE CODE
NO PAYMENT DETAILS IN MEMORY
NO SILENT EXTERNAL ACTIONS
NO CLAIM OF APPROVAL WITHOUT A RECORD
NO DELETION OF ORIGINAL EVIDENCE
NO MERGE OR DEPLOYMENT WITHOUT APPROVAL
NO MODEL OUTPUT TREATED AS AUTOMATIC TRUTH

Never commit:

Passwords
API keys
Access tokens
Private keys
Recovery codes
Payment-card information
Banking credentials
Government identification numbers
Private addresses
Confidential legal or medical records
Personal information belonging to another person

Use placeholders:

<SECRET_STORED_LOCALLY>
<PRIVATE_INFORMATION_REDACTED>
<OWNER_APPROVAL_REQUIRED>

Report suspected vulnerabilities responsibly. Do not publish exploit details that would place users or systems at immediate risk.

Faith, Identity, and Responsibility

GARVIS reflects Adrien D. Thomas’s:

Christian faith
Respect for the Ten Commandments
Cree identity
Connection to Treaty 6 territory
Commitment to Mother Nature
Respect for land and water
Concern for Missing and Murdered Indigenous Women, Girls, and Two-Spirit people
Belief in truth, accountability, dignity, and future generations

Faith and symbolism may guide values and creative exploration.

They are not automatically treated as scientific proof.

GARVIS represents the independent work and personal perspective of Adrien D. Thomas. It does not claim to speak for every Cree person, First Nation, elder, Christian community, Indigenous community, or knowledge keeper.

AGI Position

GARVIS treats artificial general intelligence as a development and research goal.

AGI_GOAL=YES
AGI_PROVEN=NO
CONSCIOUSNESS_CLAIM=NO
HUMAN_AUTHORITY_RETAINED=YES

The project does not claim that GARVIS is conscious, sentient, omniscient, or scientifically proven to be AGI.

The work focuses on measurable capabilities:

Reasoning
Memory
Tool use
Planning
Verification
Adaptation
Collaboration
Security
Reproducibility
Human alignment through explicit governance

Extraordinary claims require extraordinary evidence.

Relationship to the OpenAI Agents SDK

GARVIS is an independent ProCityHub project built on and extending the open-source OpenAI Agents SDK foundation.

The project preserves the applicable upstream license and acknowledges the work of OpenAI and the upstream contributors.

GARVIS-specific architecture, governance, research components, project direction, and creator record are developed under the direction of Adrien D. Thomas and ProCityHub.

Connected Projects

Thunderbird — public identity and planned interface
HyperCube Heartbeat — reasoning, Lattice research, and validation
ProCityHub — organization and project ecosystem

Roadmap

Foundation

Governed intelligence

Unified approval ledger
Signed stage-transition records
Complete action-risk classification
Stronger evidence provenance
Reversible tool transactions
Expanded security test suite
Standardized agent constitutions
Auditable long-term memory

Thunderbird interface

Long-term direction

Native Android integration
Reversible launcher interface
Device-level voice assistant
Secure computer-use capabilities
Governed multi-agent collaboration
Research and business workspaces
Human-controlled personal AI operating environment

Who Should Join?

GARVIS welcomes people who believe AI can be ambitious without becoming careless.

You may belong here if you care about:

AI agents
Python engineering
Local models
OpenAI systems
Safety and security
Memory architecture
Human–AI interaction
Evidence and provenance
Mobile development
Voice systems
Reproducible research
Indigenous technology sovereignty
Environmental responsibility
Open-source collaboration
Building tools that genuinely help people

You do not need to agree with every hypothesis to contribute.

You do need to respect:

EVIDENCE
ATTRIBUTION
SECURITY
HUMAN DIGNITY
CLEAR PERMISSION
HONEST UNCERTAINTY

The strongest contributors are not those who praise every idea.

They are the ones willing to test ideas carefully, identify weaknesses respectfully, preserve what works, and improve the system without erasing its creator or mission.

Contribution Process

Before contributing:

Read the repository documentation.
Review the governed and frozen file lists.
Open an issue describing the proposed change.
Separate established behavior from experimental ideas.
Add or update tests.
Run the complete check suite.
Submit a focused pull request.
Do not merge or deploy without approval.

make check

A good contribution should explain:

What problem it solves
What files it changes
What evidence supports it
What tests were run
What security risks were considered
What remains uncertain
Whether the change enables an external action
Which approval stage is required next

Creator Attribution

GARVIS was created and is directed by Adrien D. Thomas.

GARVIS, Thunderbird, HyperCube Heartbeat, and related Lattice research form part of Adrien D. Thomas’s independent research, software-development, and project-creation record.

Please preserve creator attribution when discussing, testing, adapting, citing, or distributing this work.

Suggested citation:

@software{thomas_garvis,
  author    = {Thomas, Adrien D.},
  title     = {GARVIS: Governed Artificial Intelligence for Human-Directed Creation},
  publisher = {ProCityHub},
  year      = {2026},
  url       = {https://github.com/ProCityHub/GARVIS}
}

Project Identity

CREATOR: ADRIEN D. THOMAS
PROJECT: GARVIS
ORGANIZATION: PROCITYHUB
PUBLIC INTERFACE: THUNDERBIRD
REASONING CYCLE: HYPERCUBE HEARTBEAT
RESEARCH LAYER: LATTICE VALIDATION
CLOUD AI DIRECTION: OPENAI
OPERATING MODEL: LOCAL FIRST · CLOUD BY CHOICE
AGI STATUS: DEVELOPMENT GOAL
FINAL AUTHORITY: ADRIEN D. THOMAS
CORE LAW: CAPABILITY IS NOT AUTHORIZATION

The Invitation

GARVIS is not only an attempt to build a more capable AI.

It is an attempt to build a better relationship between intelligence and authority.

A system that can grow without hiding what it is doing.
A system that can help without taking ownership of the human.
A system that can remember without betraying privacy.
A system that can act—but knows when it must ask.
A system that can imagine boldly and still submit its claims to evidence.

Build intelligence that deserves trust.

Build tools that return power to people.

Build with us.

Created by Adrien D. Thomas
For truth. For dignity. For the land. For the future.

Name		Name	Last commit message	Last commit date
.garvis		.garvis
.github		.github
.vscode		.vscode
ci-fix-bot		ci-fix-bot
config		config
directives		directives
docs		docs
examples		examples
genesis-x		genesis-x
hypercube_protocol		hypercube_protocol
prototypes/gpt_quantum_ui		prototypes/gpt_quantum_ui
research/quantum/prime_oab		research/quantum/prime_oab
scripts		scripts
src		src
tests		tests
tools		tools
.gitignore		.gitignore
.prettierrc		.prettierrc
AGENTS.md		AGENTS.md
BINARYBRAIN		BINARYBRAIN
CLAUDE.md		CLAUDE.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
FROZEN_FILES.txt		FROZEN_FILES.txt
GOVERNED_FILES.txt		GOVERNED_FILES.txt
LICENSE		LICENSE
Makefile		Makefile
NOTICE-GARVIS		NOTICE-GARVIS
PREREGISTRATION.md		PREREGISTRATION.md
README.md		README.md
RETRACTIONS.md		RETRACTIONS.md
golden_ratio_optimization.py		golden_ratio_optimization.py
hypercube_integration.py		hypercube_integration.py
hypercube_network.py		hypercube_network.py
knowledge_base.md		knowledge_base.md
mkdocs.yml		mkdocs.yml
prime_consciousness_integration.py		prime_consciousness_integration.py
pulse.py		pulse.py
pyproject.toml		pyproject.toml
reasoning_chain.md		reasoning_chain.md
uv.lock		uv.lock

Latest commit

History

Folders and files

Repository files navigation