Building MyZubster as a Verifiable AI Development Ecosystem

Leader ●2 ●22 ●155
calendar_today • schedule11 min read

uilding MyZubster as a Verifiable AI Development Ecosystem: Metaverse, GitHub Evidence, Zorgax Knowledge, and DevelopmentRequest
Today we had the opportunity to present and demonstrate part of the MyZubster ecosystem during an institutional hearing.
Instead of presenting only slides or a conceptual roadmap, we showed the system directly. We opened the MyZubster metaverse, explained a real pilot involving an actual user, discussed how GitHub activity can become technical evidence, and described the architecture we are building around Zorgax, verified knowledge, software development, wallets, and human review.
The most important outcome for us was not the meeting itself.
It was realizing that the different components we have been building are starting to form a coherent technical system.
The architecture is moving toward this loop:
Real Person

↓

Real Activity

↓

Data / Evidence

↓

MyZubster

↓

Verified Knowledge

↓

Zorgax AI

↓

DevelopmentRequest

↓

Developer

↓

Code / GitHub

↓

Tests

↓

Independent Verification

↓

New Knowledge

↓

Identity / Wallet

↓

Metaverse Interaction
The goal is not simply to build another AI assistant, another marketplace, or another metaverse.
The goal is to connect all of these components around one principle:
AI can assist the process, but evidence and verification should remain inspectable.

The Metaverse Is Only the Interface
One of the things we demonstrated was the MyZubster metaverse.
For us, the metaverse is not the entire product.
It is one possible user interface for a much larger system.
The long-term idea is that a user should eventually be able to enter the environment with a digital identity, connect a wallet, interact with people or services, and have access to a history of technical contributions and activities.
That means the visible environment may look like a metaverse, but behind it we want something closer to a verifiable contribution graph.
A person may have:
Identity
↓
Wallet
↓
GitHub Account
↓
Issues
↓
Pull Requests
↓
Commits
↓
Tests
↓
Reviews
↓
Verified Contributions
The important distinction is that a wallet alone does not prove contribution.
A GitHub account alone does not prove contribution either.
What matters is the history of actions and the evidence attached to them.
A commit may be evidence.
A passing test may be evidence.
A reviewed pull request may be evidence.
A reproducible result may be evidence.
But none of these should automatically be interpreted as proof of everything.
That distinction becomes very important once AI is involved.
A Real Pilot: Nicola
We also presented a real pilot involving Nicola, one of the people testing and contributing to the ecosystem.
The first experiment was intentionally simple.
A physical kefir handover was performed and digitally recorded through MyZubster.
The workflow represented something like:
HAND_DELIVERY

↓

Receiver confirms receipt

↓

Status updated

↓

RECORDED
There was no payment involved.
The specific transaction was also not recorded as an on-chain blockchain transaction.
That is important because we do not want to describe the experiment as something it was not.
The purpose was not to scientifically validate kefir.
The purpose was to answer a much more technical question:
Can a real-world event be represented digitally in a way that produces useful evidence?

The answer was yes.
From there, Nicola also tested other parts of MyZubster, reported problems, and worked on his own software.
That gave us a more interesting participation model.
Instead of thinking about users as static roles, we can model participation as a progression:
User
↓
Tester
↓
Contributor
↓
Developer
↓
Evidence Producer
↓
Knowledge Contributor
This is one of the ideas that could eventually connect the metaverse, GitHub, wallets, community reputation, and Zorgax.
Zorgax: Chat Is Not Knowledge
One of the most important architectural decisions we have made recently concerns Zorgax.
We do not want to treat an AI-generated answer as verified knowledge.
That sounds obvious, but many systems effectively do exactly that.
A language model generates a response.
The response is stored.
Later the system retrieves that response as if it were truth.
That is dangerous.
So our architecture starts from a different assumption:
A message is not knowledge.

A message may contain useful information.
It may become a candidate for knowledge.
But it must go through additional stages.
Our conceptual flow looks like this:
User Question

↓

AI Response

↓

Candidate Information

↓

Sources

↓

Evidence

↓

Human / System Review

↓

Verified Knowledge
Only after that should the information become part of a trusted knowledge layer.
The Zorgax Knowledge Layer
We have been building a dedicated Knowledge Layer for Zorgax.
The knowledge model is designed to preserve more than just text.
A useful knowledge object needs context.
It may include concepts such as:
Knowledge
├── contributionId
├── title
├── content
├── contentHash
├── version
├── status
├── visibility
├── provenance
├── source
├── evidence
└── lineage
The contentHash is particularly important.
It gives us a deterministic identity for the canonical content.
If the content changes, the hash changes.
This allows downstream systems to know exactly which version of knowledge they are using.
For example, a development task may reference:
{
"contributionId": "ZK-123",
"contentHash": "f30c...",
"version": 3,
"title": "Metaverse Identity Architecture"
}
Later, the knowledge may evolve to version 4.
The development task should still be able to show:
This implementation was based on version 3.

That creates much better provenance.
Preview Before Persistent Writes
Another principle we implemented is:
The AI should not silently perform consequential writes.

For operations such as creating a DevelopmentRequest, the system first produces a preview.
Conceptually:
User Intent

↓

Normalized Input

↓

Knowledge Snapshot

↓

Preview

↓

Digest

↓

Explicit Confirmation

↓

Persistent Write
A digest is generated from the preview.
Then the user must confirm using a value such as:
CONFERMA DEV a1b2c3d4
If the preview changes, the digest changes.
If the digest does not match, the operation fails.
This prevents a situation where the user approves one thing and the system writes something different.
DevelopmentRequest: Turning Knowledge Into Work
The next architecture problem was:
How do we transform verified knowledge into software development?

Our solution is a new neutral object called DevelopmentRequest.
A DevelopmentRequest is not a bounty.
It is not a GitHub issue.
It is not a payment request.
It represents the work that needs to be done.
The current lifecycle is:
DRAFT
↓
OPEN
↓
IN_PROGRESS
↓
SUBMITTED
↓
VERIFIED
or:
SUBMITTED
↓
REJECTED
The model also supports cancellation.
Conceptually, the object contains:
DevelopmentRequest {
requestId
requestHash
createdBy

title
description

knowledgeRefs[]

requirements[]
acceptanceTests[]
evidenceRequired[]

status
assigneeId

submission
review

bountyReference // optional
}
The important part is that the development request is anchored to verified knowledge.
Snapshotting Knowledge
When a DevelopmentRequest is created, Zorgax does not simply store a knowledge ID.
It stores a snapshot reference.
For example:
knowledgeRefs: [
{

contributionId: "ZK-123",
contentHash: "abc123...",
version: 2,
title: "Verified Architecture"

}
]
Before the request is actually committed, the system revalidates those knowledge references.
If the underlying content has changed between preview and commit, the operation fails.
Conceptually:
if (
expected.contentHash !== current.contentHash ||
expected.version !== current.version
) {
throw new Error(

"Knowledge changed after preview"

);
}
This gives us something extremely useful:
development provenance.
We can eventually say:
Feature X
was implemented because of
DevelopmentRequest Y
which was based on
Knowledge Z version 2
which came from
Evidence A + Evidence B
That is much stronger than simply linking a GitHub issue to a random conversation.
Submission Is Not Verification
This is another important rule.
A developer may submit something.
That does not mean the work is verified.
So the workflow separates:
SUBMITTED
from:
VERIFIED
The contributor submits evidence such as:
{
"evidenceRefs": [

"test:integration:green",
"demo:https://..."

],
"commitRefs": [

"commit:abc123"

]
}
But a separate reviewer is responsible for verification.
The reviewer cannot be the creator or the assigned developer.
Conceptually:
if (
reviewer === request.createdBy ||
reviewer === request.assigneeId
) {
throw new Error(

"Review must be independent"

);
}
This is one of the foundations for future contribution reputation.
Strengthening the Evidence Model
We are now tightening this further.
The first implementation verified that evidence existed.
But that is not enough.
Imagine this DevelopmentRequest:
Evidence required:

  1. Unit tests pass
  2. Security review completed
  3. Metaverse integration demonstrated
    And the developer submits only:
    commit:abc123
    Technically, evidence exists.
    But the required evidence is not actually satisfied.
    So the stronger model connects each requirement to a specific reference.
    For example:
    {
    "evidence": [ { "requirement": "Unit tests pass", "reference": "ci:test-run:4821" }, { "requirement": "Security review completed", "reference": "review:security:913" }, { "requirement": "Metaverse integration demonstrated", "reference": "demo:metaverse:42" } ]
    }
    Then the verification rule becomes:
    VERIFIED
    only if
    every evidenceRequired item
    has corresponding evidence
    Conceptually:
    const missingEvidence =
    requiredEvidence.filter(
    requirement =>
    !coveredRequirements.has(requirement)
    );

if (missingEvidence.length) {
throw new Error(

`Missing required evidence: ${missingEvidence.join(", ")}`

);
}
This may look like a small implementation detail.
It is not.
It changes the meaning of VERIFIED.
Without this rule:
VERIFIED = someone attached something
With this rule:
VERIFIED = the declared evidence requirements were actually covered
That is a much stronger guarantee.
DevelopmentRequest Is Not a Bounty
Another architectural decision we intentionally made was separating development from economics.
A DevelopmentRequest can exist without any reward.
That means:
Knowledge
↓
DevelopmentRequest
↓
Implementation
↓
Verification
can operate independently.
Then, optionally:
DevelopmentRequest
↓
Bounty
↓
Reward
↓
Settlement
may be attached later.
This distinction matters.
A university research project may not use bounties.
An open-source volunteer may contribute without payment.
A company may use fixed contracts.
A decentralized community may use tokens.
A marketplace may use fiat.
The technical work object should not care.
That is why the model contains only:
bountyReference: null
as an optional link.
The economics remain a separate subsystem.
GitHub as Evidence, Not Truth
GitHub is also important in the architecture, but we do not want to make the mistake of treating GitHub itself as truth.
A commit proves that a commit exists.
It does not automatically prove:
the feature works
the requirement is satisfied
the code is secure
the architecture is correct
the scientific result is valid
So GitHub becomes one evidence source among others.
Future DevelopmentRequest verification could combine:
GitHub commit
+
CI test result
+
integration test
+
human review
+
external evidence
This is also why we are working toward a Contribution Graph.
The graph can connect:
Developer
↓
Issue
↓
DevelopmentRequest
↓
Commit
↓
Pull Request
↓
Test
↓
Review
↓
Verified Contribution
That provides a much richer representation of technical reputation.
Where the Metaverse Fits Back In
At first glance, the metaverse and DevelopmentRequest may seem unrelated.
But they are actually part of the same architecture.
Imagine a person entering MyZubster.
The environment could eventually know:
Identity
Wallet
GitHub History
Verified Contributions
Knowledge Contributions
Development Activity
Community Activity
The user does not need to see all of this as raw database records.
The metaverse can become an interface for it.
For example, someone could enter a virtual lab or development room and interact with a project.
Behind the scene:
Metaverse Project

   ↓

DevelopmentRequest

   ↓

Verified Knowledge

   ↓

GitHub Repository

   ↓

Contributors

   ↓

Evidence
The virtual environment therefore becomes a way to navigate a real technical graph.
What We Demonstrated Today
During the hearing, we were able to connect several of these concepts in one presentation.
We demonstrated the MyZubster metaverse directly.
We explained Nicola's real-world pilot.
We discussed his AI-related development work.
We explained how user activity can evolve into testing and software contribution.
We described the role of GitHub history.
We explained Zorgax.
We described the difference between AI conversation and verified knowledge.
We presented our university outreach and the idea that scientific pilots require scientific methodology.
And we explained the broader direction:
People perform real activities, software records evidence, AI assists the process, developers build solutions, and independent verification creates new trusted knowledge.

Universities and Scientific Validation
We also discussed the academic side of the project.
We have started conversations with several universities and research groups around areas including AI, food science, fermentation, circular economy, environmental measurement, LCA/LCSA, and water reuse.
We are intentionally keeping the wording precise.
These are exploratory discussions.
They are not formal partnerships unless and until they are formally established.
The reason universities matter is structural.
MyZubster can build:
software
traceability
data collection
knowledge infrastructure
AI assistance
development workflows
evidence systems
But scientific validation requires additional layers:
scientific protocol
experimental design
control groups
measurement methodology
ethical assessment
statistical analysis
domain expertise
An AI system should not pretend to replace those responsibilities.
LIFE 2027 as a Possible Pilot Framework
We are also exploring whether some of these ideas could eventually fit into a LIFE 2027 project.
Again, this is an exploratory direction.
There is no approved or funded MyZubster LIFE project at this stage.
The interesting part for us is the possibility of connecting environmental pilots with the same verifiable architecture.
For example:
Circular Water Pilot

  ↓

Sensors / Data

  ↓

Evidence

  ↓

University Protocol

  ↓

Verified Knowledge

  ↓

Zorgax

  ↓

DevelopmentRequest

  ↓

Software Improvement
The same architecture could theoretically apply to fermentation, environmental monitoring, circular economy, Living Labs, or other pilot domains.
That is one reason we are trying to keep the core infrastructure domain-neutral.
The Broader Architecture
If we compress the whole system, the current direction looks like this:

                ┌──────────────────┐
                │    Real World    │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ Data / Evidence  │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ MyZubster        │
                │ Knowledge Layer  │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │      Zorgax      │
                │   AI Assistant   │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │DevelopmentRequest│
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │    Developer     │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ GitHub / CI      │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ Evidence Review  │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ Verified Result  │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │  New Knowledge   │
                └────────┬─────────┘
                         │
                         ▼
                ┌──────────────────┐
                │ Identity/Wallet  │
                │ Metaverse Layer  │
                └──────────────────┘

This creates a feedback loop.
The output of development can become new knowledge.
That knowledge can generate new development requests.
Those development requests create more evidence.
The evidence can improve the knowledge layer.
What We Have Implemented So Far
At the technical level, the recent work includes:

  • a Zorgax Knowledge Layer with provenance, content hashing, versioning, visibility and evidence metadata;
  • explicit distinction between conversation, candidate information and verified knowledge;
  • fail-closed behavior for sensitive knowledge operations;
  • preview + digest + explicit human confirmation before persistent DevelopmentRequest creation;
  • snapshotting of Knowledge references using contentHash and version;
  • idempotent DevelopmentRequest creation;
  • a lifecycle covering DRAFT, OPEN, IN_PROGRESS, SUBMITTED, VERIFIED, REJECTED and CANCELLED;
  • contributor assignment;
  • submission of commit and evidence references;
  • independent review rules;
  • strict separation between DevelopmentRequest and bounty/payment systems;
  • integration points for future GitHub contribution tracking;
  • an evidence model being strengthened so every required evidence item must be satisfied before VERIFIED.
    This is still evolving.
    There are important areas we still want to improve, including stronger revision models, more precise evidence objects, route-level tests, better contribution graph integration, and stronger lineage across Knowledge revisions.
    The Principle Behind the Architecture
    The most important idea is probably this:
    We are not trying to automate trust.

We are trying to make trust more inspectable.
AI can help generate code.
AI can help search.
AI can help organize knowledge.
AI can help transform requirements into development tasks.
AI can help developers.
But an AI response should not automatically become truth.
A commit should not automatically become proof.
A wallet should not automatically become reputation.
A submission should not automatically become verification.
The architecture should preserve the difference.
That is what we are trying to encode in the system itself.
What Comes Next
The next engineering steps are straightforward.
We want to finish the stronger DevelopmentRequest evidence invariant, integrate the workflow into the operational branch, and then continue toward the GitHub and Contribution Graph bridge.
After that, we want Zorgax to be able to move through a much richer development loop:
Question
↓
Verified Knowledge
↓
Architecture
↓
DevelopmentRequest
↓
Implementation
↓
Tests
↓
Independent Verification
↓
Delivery
↓
Optional Reward
↓
New Knowledge
At the same time, we will keep exploring how this architecture can work with real users, academic research, environmental pilots, and the MyZubster metaverse.
The meeting today was useful because we did not have to describe this only as an abstract roadmap.
We were able to show pieces of it working.
There is still a lot to build.
But the architecture is becoming increasingly clear.
Real people create activity. Activity creates evidence. Evidence can become verified knowledge. Knowledge can generate development. Development creates new evidence. AI assists the entire loop without becoming the sole authority.

That is the direction we are building toward with MyZubster and Zorgax.
MyZubster
Open Source • Verified Knowledge • AI-Assisted Development • GitHub Evidence • Metaverse • Digital Identity • Community

AI #OpenSource #SoftwareArchitecture #SoftwareDevelopment #GitHub #Metaverse #Web3 #KnowledgeGraph #ArtificialIntelligence #NodeJS #Developers #MyZubster #Zorgax

🔥 Join developers growing publicly
Share your knowledge, build in public, and grow your developer presence with a global community.

More Posts

The Sovereign Vault — A Comprehensive Guide to Protocol-Driven AI

Ken W. Algerverified - Jun 4

Dozens of email accounts: learning AI coding tools as a student

rahuldk1105 - Oct 27

AAIF Hits 10 Projects. Its CTO on What to Adopt Now and the Security Gaps Left Open

Tom Smithverified - Oct 23

Local-First: The Browser as the Vault

Pocket Portfolio - Apr 20

How AI Is Changing Web Development, and What Developers Still Need to Understand

Daniel Decker - Nov 10
chevron_left
4.4k Points • 179 Badges
Rimini
112Posts
17Comments
33Connections

Related Jobs

View all jobs →

Commenters (This Week)

3 comments
3 comments

Contribute meaningful comments to climb the leaderboard and earn badges!