[MINUTES] CCG Incubation 2026-03-03

This meeting of the Verifiable Issuers and Verifiers call focused on the
evolving data model and its applications, with particular attention to
interoperability and use cases. Key discussions revolved around the
renaming of the group, the practical implementation of verifiable
recognition credentials, and how these credentials can integrate with
existing trust lists and federated identity systems. The group explored
ways to make the specification more decentralized and extensible, aiming to
accommodate various existing data formats and future integrations.

*Topics Covered:*

   - *Group Renaming:* A mailing list discussion and upcoming ranked-choice
   poll are underway to rename the Verifiable Issuers and Verifiers group.
   - *Verifiable Recognition Credential Model:* The group is shifting
   towards a simpler, high-level language for verifiable recognition, focusing
   on entities and their recognized actions rather than a single, generalized
   data model. This approach aims for decentralization and compatibility with
   existing systems.
   - *Interoperability with Existing Systems:* Discussions explored how the
   verifiable recognition credential model can reference and integrate with
   various existing trust lists, registries, and federated identity systems
   like UD wallet, OpenID Federation, EBSI, and the Czech blockchain. The
   approach is to reference, sign, and potentially hash these external
   resources.
   - *Use Case Application:* There's a recognized need to apply the
   developed model to various use cases to identify rough edges and ensure its
   comprehensiveness, with a call for more content to be added to the use
   cases document.
   - *Protocol Agnosticism:* The verifiable recognition credential model is
   intended to be protocol-agnostic, allowing for its use in different
   communication streams and protocols like VCOM and potentially OIDC for VP.
   - *Holder-Based Delivery and Discovery:* The discussion touched upon how
   verifiable recognition credentials can be requested, presented, and
   discovered by holders and verifiers through various mechanisms, including
   publishing them in service directories.
   - *Output Validation Clarity:* The need for more explicit definitions
   regarding the handling of multiple values for attributes, particularly in
   output validation, was discussed, focusing on the distinction between
   single triples versus multiple triples for representing data schemas. The
   current spec text was identified as potentially confusing when interpreted
   as RDF.
   - *Data URL Specification:* Ted Thibodeau Jr. raised an issue regarding
   the permissibility of data URLs within the specification, suggesting a need
   for clearer definitions.
   - *Governance and Expectation Setting:* The importance of governance in
   issuing verifiable recognition credentials, especially concerning the
   validity of schemas used in output validation, was highlighted. This
   includes ensuring that issuers maintain the integrity of referenced schemas
   and lists.

*Action Items:*

   - *Manu's Mailing List:* Participants are encouraged to chime in on the
   mailing list regarding the renaming of the group and await the upcoming
   ranked-choice poll.
   - *Isaac Henderson:* Isaac will review the use cases document and
   provide comments for the next meeting.
   - *Benjamin Young:* Benjamin will create a "super issue" to begin
   discussing and identifying other communities and ecosystems for potential
   integration.
   - *Dave Longley:* Dave will add a comment to issue #48 on the mailing
   list with his thoughts on holder-based delivery in relation to verifiable
   recognition credentials.
   - *Benjamin Young:* Benjamin will try to engage Stephen Curran to attend
   future calls to discuss issue #46 concerning UNP and DID lookups.
   - *Ted Thibodeau Jr. and Dave Longley:* Ted and Dave will work on
   refining the language in the spec to clarify the representation of output
   validation, particularly concerning multiple data schemas and the
   distinction between JSON modeling and RDF triples. Benjamin will post the
   drafted RDF translation for comment.
   - *Benjamin Young:* Benjamin will investigate the possibility of
   creating a PR for issue #44 related to data URLs, or Ted can send one.
   - *Benjamin Young:* Benjamin will add a comment to issue #43 regarding
   the removal of outdated comments from the use cases document.
   - *Dave Longley and Benjamin Young:* Dave and Benjamin will consider
   creating an issue to illustrate an example that combines referencing other
   lists and defining output validation schemas within a single verifiable
   recognition credential.
   - *Isaac Henderson:* Isaac will send an email to the CCG mailing list to
   schedule a demo of his previous implementation of a unified approach for a
   future call.

Text: https://meet.w3c-ccg.org/archives/w3c-ccg-ccg-incubation-2026-03-03.md

Video:
https://meet.w3c-ccg.org/archives/w3c-ccg-ccg-incubation-2026-03-03.mp4
*osb-nmyo-muh (2026-03-03 11:00 GMT-5) - Transcript* *Attendees*

Benjamin Young, Dave Longley, Denken Chen, Elaine Wooton, Isaac Henderson,
Parth Bhatt, Ted Thibodeau Jr
*Transcript*

Benjamin Young: Hey, good morning.

Parth Bhatt: Hello.

Benjamin Young: We'll probably give it till 5 after. I'm not sure how many
people are going to show. Manu I know is away. Long may show up and we can
talk about what to do next.

Benjamin Young: Hey Dave, I might give it just a couple more minutes in
case a land or others show up and then we'll get started.

Benjamin Young: Hey Isaac, we're giving it about another minute for folks
to wander in and…

Isaac Henderson: Hi everyone.

Benjamin Young: then we'll get started.

Benjamin Young: Okay, I don't think there's a thundering horde waiting to
show up, so we will go ahead and start. this is the verifiable issuers and
verifiers call. which may be being renamed and there's a email about that
on the mailing list that's worth your time if you have interest in speaking
up on that. Let me see if I can find the issue. Okay, it's in chat here. We
lost it.

Benjamin Young: So this issue is from Manu just saying there's a vote
mailing list so if you have thoughts about the renaming, please chime in on
that mailing list and then I think Manu is going to send out a ranked
choice poll sometime next week about it or later this week probably. so
that's kind of the bigger concrete thing going on. Isaac, I think maybe
you've been here in the past,

Benjamin Young: but would you like to take a minute to introduce yourself?

Isaac Henderson: Yeah, sure.

Isaac Henderson: Yeah. yeah. So, I'm c from working in, Fronoff based in
Germany on Stutkat. Yeah. So I was also part of working or this draft from
myself and David worked on this previously and also last two months I was
on parent leave so that's why I couldn't join and I saw a good progress or
I think in the past 2 months or 3 months I think it was really interesting
that it's also manual also mentioned in the email that it is progressing
towards a working group I'm happy to contribute
00:05:00

Isaac Henderson: And yeah, so I'm looking forward and also looking forward
to contribute to this work further because I think David is retired
currently and I think he's also taking away a while. So I think so he might
not join…

Isaac Henderson: but yeah so I also definitely am happy to contribute my
inputs and also later I can have some couple of comments on the names maybe
I will also talk about that.

Benjamin Young: Okay. Yeah.

Isaac Henderson: Thank you.

Benjamin Young: No, that sounds great. yeah,…

Benjamin Young: I knew I'd seen your name floating around mostly in emails,
I guess. it's great to have you here because I think that was a farewell
email from David. So he might wander back in, but I don't think we can
expect him to be regular anymore. Yeah. thank you for being here. great. we
can talk a little bit about the document title change, if anyone has
thoughts on that. but I think, the goal was to do that mostly over the rank
choice voting thing.

Isaac Henderson: Yeah, that's true.

Benjamin Young: does anybody want to discuss the document title or should
we tackle some issues

Isaac Henderson: Yeah, sure.

Isaac Henderson: I can jump in or I can also have so I find it interesting
as a verifiable recognition. so I also went through the document of the
current status of where it is for example. Please correct me if I am wrong.
so currently the aim because previously we were trying to create a
generalized data model which can be used by issuers or verifiers or wallets
for identifying the verifiable or the trustworthy one.

Isaac Henderson: Trust is a complicated name for example but currently you
want to represent those trust the service provider or the relying parties
as a verifiable credential if I'm understanding it right and the list is
also a form of verifiable credential so that means all these data endpoints
or the metadatas will be represented as a verified

Isaac Henderson: tribal credential right for example and if who is
controlling the list that is something is up to discussion or who is going
to issue those credential can it be selfisssued and how and who is able to
validate those trustworthiness behind that issuance for example so that was
also something for me to I was trying to understand based on the current
proposal actually and the application behind how is it going to be
implemented or how it is synchronizing with the current developments with
the UD wallet any other certification schemes where it is planned so how
our work is going to be taken over there so that this is also something
which I'm looking to identify and…

Isaac Henderson: understand actually the scope of where we are going so
that I can also come up with better names so thank

Benjamin Young: Yeah, that's great.

Benjamin Young: That's great. go ahead, Dave.

Dave Longley: To speak to some of that. so over the last few weeks, I guess
maybe it's been a couple months as well. what we have found in this work is
that there are a number of different groups that have their own data models
and lists of things and software around those for parsing all that. And we
didn't want to require those groups to necessarily change any of those bits
of their software. But we wanted it to be compatible with issuing
verifiable credentials that could list these other entities both as for a
directory use case where you can describe what these other entities are and
then link to these other lists that they have that are in these other
formats with this other software that already works.

Dave Longley: And we found that trying to make a single unified data model
that covers some of the things that are in the UD lists would probably be a
little bit challenging and…

Isaac Henderson: Mhm. Yeah.

Dave Longley: probably there wouldn't be a good incentive for them to
switch over if they've written all the software to consume that already.
but what we did want to do is make sure that that model sort of takes the
authoritative approach that there's an authority that's allowed to do this
and allowed to do that and so on. And we wanted the spec that we were
producing to talk more about recognition and…

Isaac Henderson: Mhm. Yeah.
00:10:00

Dave Longley: be more decentralized so that anyone can say anything about
anything and anyone can talk about who they recognize to issue this
credential or ask for this or whatever.

Isaac Henderson: Yeah. Yeah.

Dave Longley: And so we sort of pivoted in that direction and came up with
a very simple highle language for talking about you can recognize these
entities and you can recognize them to take these certain actions like
issue this type of credential and then we associate a JSON schema with that
just as an example. and that made the spec a lot simpler and it gave us the
ability to link into these other systems and allow them to reuse it. And so
anyone using this spec can consume these VCs and then link out to these
other systems if they have software that works with those other systems. So
that was sort of the unifying approach we had. Make it more decentralized,…

Isaac Henderson: That sounds a great approach actually.

Dave Longley: make it work with these other systems and make it extensible
to work with other systems that other people might bring to us that we
don't know anything about today.

Isaac Henderson: I think so for example then you're planning to have
because I think I'm trying to understand because the current list of UD
wallet or for example other registries or open ID federation so they are
represented in a different format for example right in a JSON or XML or
whatnot so are you planning to just reference those URLs in your

Isaac Henderson: list and then sign it and so whenever there's an update
coming in the open ID federation list or for example or in Etsy list or
whatnot then it gets updated and also the pointer gets referenced or hash
for example so inside so this is something is also we are considering in it
or…

Isaac Henderson: is it just okay okay mhm H.

Dave Longley: Yes. Yeah.

Dave Longley: Yeah. and there are two options there. You could sign if
there's a URL that you want to allow to change and when you fetch the URL,…

Isaac Henderson: Yeah. Yeah.

Dave Longley: it has some kind of digital signature behind it. So those
changes are okay. Then you don't have to include a hash of the content in
your VC and…

Isaac Henderson: Mhm. Okay.

Dave Longley: you can allow that to evolve over time. You also have the
option of sort of pinning it and saying when I issued this VC this was the
hash for that content and…

Isaac Henderson: Mhm. H okay.

Dave Longley: that is the only list I ever wanted to talk about with this
VC and I will issue a new VC if I want to include new content. with this
model and with this spec you have the option to do either one of those
things.

Isaac Henderson: Because couple of years back we have developed already an
implementation of this unified approach So maybe I could also share the
link with you. So you can have a look into this one. so this is also
something where we provide an unified signature approach where different
credential formats can be represented as a VC and also the hash because we
based on a hashbased approach actually because we don't want to use the
Jardis or Sardis suits actually but rather we want to use this kind of VC
as a signature trust list URI and a hash and this we already implemented and

Isaac Henderson: I think we also implemented as a part of an Eclipse
foundation project for Kaya X trust infrastructure and I think this is
something which if you are planning to incorporate into the reference
architecture I think we already have an implementation or…

Isaac Henderson: yeah we could also provide some support on that if that's
something interesting.

Dave Longley: Yeah, this looks Yeah,…

Dave Longley: this looks very similar to I think some of the names and
things would change to bring this up to date,…

Isaac Henderson: Yeah exactly.

Dave Longley: but I think…

Isaac Henderson: Mhm. Okay.

Dave Longley: what you just described is very compatible with the model
that is in the spec today. So I think there's a lot this can easily work
together.

Isaac Henderson: Great. Because I was also trying to understand when we
have multiple credential. you can have for each and every list a separate
signature because I was trying to understand when you want to reference
multiple list in a single VC because whenever it's going to get it signed
who is because different persons or different authorities or not
authorities different institutions might be in charge of updating this list
and so that's why I was just trying to think about having each credential
for a list or having you

Isaac Henderson: multiple list in a single credential. what do you think
about that actually?

Dave Longley: Yeah, I think that gets into a topic I think the group should
start covering sooner rather than later,…

Isaac Henderson: Yeah. Mhm. Yeah.

Dave Longley: which is let's take the model that we have that we've come to
over a number of months now and start trying to apply it to a bunch of
different use cases and make sure that the model that we have can address
those use cases And so if you're bringing those might be use cases that are
already in our use cases document that need some update. but they might
also be newer or it's good to have fresh eyes on them. And so We should say
we have this use case. We have this new data model that we think is going
to work for the use cases we're interested in. Let's see if it does and
let's work our way through some examples and see…
00:15:00

Dave Longley: if we've got any rough edges we need to, make adjustments for
or just make sure it works out.

Isaac Henderson: Mhm. Yeah,…

Isaac Henderson: sounds good. Yeah.

Benjamin Young: And it summarizes most of the issues there.

Benjamin Young: I think certainly the newest ones are ensure compatibility
with create example demonstrating yeah and even some of the older ones are
that way too. So I think you're both trending the right direction that we
now need to take this model we've come up with and apply it and see what
falls out. I did link to the use cases document which is a separate one now
from the main specification that's worth looking through if you haven't
seen it.

Benjamin Young: I doubt everything is covered. but it would be great to
channel more content into that soon.

Benjamin Young: Isaac, did you have any other thoughts or questions on that
general point or…

Isaac Henderson: You mean the use cases right…

Isaac Henderson: which you shared with the link Okay.

Benjamin Young: Yeah. or just where you were trending with how does this
fit wondering if it does? is there any part of that you wanted to dig into
more before we

Isaac Henderson: I think this use cases was done or it was done quite a
while back I think it's worth looking into it and also updating the details
accordingly actually I would say because I know this was done couple of
three years back this verifiable issue use case and verifiable especially
but maybe I could look onto it and…

Isaac Henderson: also give a read on that and maybe comments on before for
the next meeting for example.

Benjamin Young: That'd be awesome.

Benjamin Young: Thank you.

Isaac Henderson: Yeah, but are we planning to go into these use cases or
should we also go because since we are considering in a high level meta
should we talk about other existing ecosystems which are currently existing
by considering for example UD wallet is one what do you call this MDL and
also the check blockchain and stuff like that. compatible with both so use
cases across blockchain world and also the normal one.

Isaac Henderson: Did you have any thoughts on that or how did you plan to
go further?

Benjamin Young: Yeah,…

Benjamin Young: I don't think there is a plan and…

Isaac Henderson: Okay. Mhm.

Benjamin Young: we can make one right now. I think maybe what we can do on
this call is look at the few issues that are here that pertain to either
use cases or…

Isaac Henderson: Yeah. Yeah.

Benjamin Young: just like number 49 and number 48 48 in particular looks
very much like the kind of thing that you're describing.

Benjamin Young: And so I wonder if we should, draft a super issue to start
us out discussing what are the other communities we know of where we want
to try and…

Isaac Henderson: Exactly. Mhm.

Benjamin Young: connect the dots and then we can break that out into
separate issues. Maybe why don't we try that?

Isaac Henderson: I think that might be good because the UNP one is more
specific to the verifiable credential model or…

Isaac Henderson: the data model but there are also other as we discussed
right open ID federation or trust list which are beyond that. Yeah. Mhm.

Benjamin Young: Okay. …

Benjamin Young: So, I'm going to start this issue. and we have the UNP one.
will preview better than it looks in the text.

Benjamin Young: And there were several others that you just mentioned. The …

Isaac Henderson: So one thing I could yeah tell is the Etsy one the UD
wallet trust list for example and…

Isaac Henderson: the next one is the open ID federation and there's also
blockchain based things like EC1 that's a European blockchain E EB EBSI EBS.
00:20:00

Benjamin Young: can you spell that for me? I EBSI.

Isaac Henderson: Yeah. And…

Benjamin Young: Thanks. I knew I'd seen it.

Isaac Henderson: and then another one is the Czech blockchain for example.
So they also have a did based trust chain based on verifiable credential C
ch. Yeah. Yeah.

Benjamin Young: T H E Q D right here. Okay.

Isaac Henderson: Check blockchain. Yeah. Okay.

Benjamin Young: I think this second one is the one that David was mostly
focused on representing for and I don't know that it's completely handled.
It'd be good to have more eyes on it from folks that know this space. do
you have contacts that checked or Okay.

Isaac Henderson: Yeah, I I have contacts checked and also the epsy one so I
know how the trust framework or the list looks like and with the UD wallet
currently it's still developing so we could start with the schema

Benjamin Young: Right.

Isaac Henderson: which is currently existing from the Etsy whatever is
currently available and we could try to use that because the UD wallet is
open source and we could try to build upon that actually yeah and open ID
federation I'm not sure where it is currently applied or is it being used
somewhere else or still I'm not sure actually Mhm.

Dave Longley: Yeah, we might want to get feedback from Dimmitri on that
because I know that they're doing some work over in the education space
with that and looking to get some more privacy benefits out of using the VC
model here.

Isaac Henderson: Okay.

Dave Longley: And so he might have some input.

Isaac Henderson: And how about the valist from what is it called MDL for
example? Yeah.

Dave Longley: Yeah, we should mention they've got some trust hierarchy
stuff as well for MDL.

Benjamin Young: Very technical.

Benjamin Young: We'll run with that.

Dave Longley: Yeah, that's right.

Dave Longley: And for each of these, we're not looking to look in,…

Dave Longley: crack those open and look inside of them and take pieces out
of them. We're looking to see that we can make our data model reference and
talk about those things in useful ways and even unify them. So if you have
a given issuer that might issue both VCs and MDL and something in that is
used in the education space or anything along those lines…

Isaac Henderson: Yeah. Mhm.

Isaac Henderson: Mhm.

Dave Longley: then by having a verifiable recognition credential there
might be some utility in unifying that working with directories helping
digital wallets express information about those things.

Dave Longley: there's lots of places where those things can become unified
with this data model. it would also be good to demonstrate in any given one
of these cases if they wanted to express something that they do express
today in their model.

Isaac Henderson: Mhm. Yeah.

Dave Longley: Here's how you could express it in the model here, but that's
not a requirement for them to move over to it and they might not be
incentivized to. But there might be some advantage that they might see …

Isaac Henderson: Mhm. That's true actually.

Dave Longley: if they have an example that shows how to do

Isaac Henderson: And one thing we might also need to I think just because
especially since it's a new credential for example it would be good to also
think about where it is going to be referenced right for example is it
going to be part of the credential or is it going to be part of the
policies at the verifier side or is it going to be integrated into the
trust or in the list for example right so this is also something have you
thought about that or discussed already Yeah.

Dave Longley: And there's a couple of other issues that were just open I
guess they came in from the mailing list around where do these verifiable
recognition credential or…

Isaac Henderson: Mhm. Yeah.

Dave Longley: where do you link to them? where could you discover them? And
each one of those things can have, a different answer. So there is a goal
to allow holders to present them when requested.

Isaac Henderson: Mhm.

Dave Longley: There's a goal issu for verifiers to present them when
they're making a request to holders or holders could ask for them. there's
also this concept of publishing them did document at a…
00:25:00

Isaac Henderson: Yeah. Mhm.

Dave Longley: who is service or something.

Dave Longley: So you could publish them there and so they can be
discoverable in that way. And so there's a couple of other issues around
that and…

Isaac Henderson: Mhm. Yeah.

Dave Longley: I think we wanted all of the above approach for you you can
put these things into the various streams where you're communicating
between parties. Yep.

Isaac Henderson: 's Yeah. I think that's A good point actually and the one
which list which I shared with you actually in the link. So this one we try
to do with the document and also with So in DNS the URI record we were also
trying to create a link so that we were giving an option for users or
entities for example to use IPFS nodes or whatn not so this is also
something which we demonstrated it and maybe in upcoming sessions when we
have time I could also show one of our integrations with a relying party
with policies how we did that and maybe that's something if that is also
interesting.

Isaac Henderson: if that's interesting for a group then I can also show
that in a small demo here.

Benjamin Young: Yeah. …

Dave Longley: Yeah, I think using one of these calls to do a demo like that
would be great.

Dave Longley: Go pen.

Benjamin Young: yeah, it would be we are kind of in a trough between a
whole flurry of action and queuing up the next actions. I don't want to put
you on the spot, Isaac, to do a demo now and…

Isaac Henderson:

Isaac Henderson: No, not now actually.

Benjamin Young: it might Well,…

Isaac Henderson: in the coming weeks if you have time for the agenda.

Benjamin Young: hopefully get you a bigger audience,…

Isaac Henderson: So yeah,…

Benjamin Young: Okay, that sounds great.

Benjamin Young: And if you want to offer that on the mailing list, or just
save it, here's what you'd like to demo, then we can,…

Isaac Henderson: okay. Yeah,…

Benjamin Young: pick an upcoming Tuesday to schedule that for.

Isaac Henderson: where I could send you by email or for example.

Benjamin Young: Yeah, that'd be fine.

Isaac Henderson: Okay. Mhm.

Benjamin Young: Just to the CCG mailing list,…

Isaac Henderson: Perfect. Yeah.

Benjamin Young: that'd be great. Okay, let's take a little bit of time to
look at maybe some of these other issues. And I'm still waiting on
permission level enough to close things, but we can leave comments on
stuff. this one seems sort of related to our general conversation so far.

Dave Longley: Yeah, I'm not sure if we end up I mean one way we can talk
about this is we could reference the VCOM spec and talk about how either
party in an exchange could request or share a verifiable recognition
credential. So we could talk about that. we could also talk about it just
more at a higher level. but it might be nice to be able to link to a
specific way to do it in a particular protocol. but we should definitely in
this spec talk about how protocols can have different parties share these
credentials or…

Dave Longley: request these credentials.

Isaac Henderson: Mhm.

Benjamin Young: So, more than just use case additions.

Benjamin Young: I'm just making sure to call out that it's okay.

Dave Longley: Yeah, I think we'd want to ground it in a use case or…

Dave Longley: two. it's like why would I do this? So here's a use case or
two. and then we can talk about how it can be done. if you have any other
use case that could reuse that primitive.

Benjamin Young: Right. Okay.

Benjamin Young: Anyone have interest in taking this on or drafting some
piece of it?

Dave Longley: I'm wondering if it would be nice if Stephen Curran came to
one of these calls to tell us when you clicked on that link did he give us
his specific use case? I don't know…

Benjamin Young: He mentions did…

Dave Longley: if Right.

Benjamin Young: who is because that's his primary focus at the moment.

Benjamin Young: is it? Yeah.

Dave Longley: Yeah, we might want to come up with a good use case for…

Dave Longley: what we're trying to cover. So, I don't know if today is the
best time to do that. We might want to get some other people on the call.
But I think a good way to address this issue is to say here's a good use
case or two for what we're trying to do with this particular feature and
then it'll be more obvious to someone who could write a PR around it to do
an example and so
00:30:00

Benjamin Young: How's this? I'll delegate to somebody not yet in the group
and see if we can get Stephen to join us.

Dave Longley: Yeah. I think at a high level what comes to my mind on this
issue a holder show is going to engage in an exchange with a verifier but
the holder wants information from the verifier about who they are first and
so they might say here are the parties I recognize to that I would be
willing to present this credential to and…

Benjamin Young: …

Dave Longley: so that's where my mind went with this but It could go in
some other direction.

Benjamin Young: would you be up for sharing that in text on the issue or
copying and pasting out of the transcription that just happened?

Dave Longley: Yeah, I'll open up the issue and leave a little note.

Benjamin Young: That'd be awesome. anyone else want to share anything
related to this issue? Otherwise, I think it's kind of a exploratory one
for whoever wants to pick it up.

Isaac Henderson: So I'm just trying to understand so this is holder based
delivery is it specific to some protocol or is it something we are thinking
it in quite general terms actually for example in the open ID for VP or…

Isaac Henderson: so ditcom for example so is it specific to that protocol
base or is it something protocol agnostic? Okay.

Benjamin Young: Yeah, I think the imagined context for both Manu and…

Benjamin Young: Dave is bol, but I think it's meant to be protocol agnostic
and I think Stephen is mostly just focused on where that did lookups could
be entangled in that process.

Benjamin Young: And he's wanting to make sure that I did who is lookup can
be part of that chain or flow is probably a better word.

Isaac Henderson: Okay. Yeah.

Isaac Henderson: Because I think then we might not address the broader spec
of this UD trust list. So then our scope also might get redu reduced So
then we can concentrate only certain because the UD wallets so currently
they are completely going with the open id for VP so this protocol is
already fixed for example. so that's why I was just thinking so when we
focus on dits then our scope also might get reduced or how do you see that
for example

Isaac Henderson: Mhm. Yeah.

Dave Longley: So I think in our spec we should at least talk in a high
level about if your protocol allows you to request credentials or present
credentials then here is how these are the types of credentials you could
request and present and then we might link to specific protocols that can
show how to do that in an example. And certainly you could do that in VCOM
and you might be able to do that with some of the upcoming versions of oid
for example…

Dave Longley: because they have an interactive presentation piece of it.

Isaac Henderson: Yeah. Heat.

Dave Longley: So there might be ways to do it with some of the draft specs.
so we might focus on VCOM since that's also in the W3C work at this time
and that'll be a little easier.

Dave Longley: But we should definitely talk about it at a high level …

Dave Longley: if your protocol supports requesting and…

Dave Longley: presenting credentials, here's something you can

Isaac Henderson: Yeah, that's true.

Benjamin Young: Yeah, that makes sense.

Benjamin Young: Okay, I think we will move on to the next issue if that's
all right. Which Wait a minute. Yeah, these are very related.

Benjamin Young: is more of the same. I think this is more the specifics of
is the concrete inter relation of the two formats but it's interdependent
with 48. wait he says 40. Okay, he's stacked 49, and 50 are all related.
So, let's go to 48. Or maybe he picked the wrong one. Does anybody know if
UNP uses did who is?
00:35:00

Benjamin Young: I think Manu got his Stevens crossed.

Isaac Henderson: I know UNP uses the did web actually…

Isaac Henderson: but I'm not sure did web VH actually so VH is something
new or…

Benjamin Young: Right. Right.

Isaac Henderson: least in the did UNP because I think that's supposedly
specific for this battery pass or the product passports so I'm not sure so
whether they are using did VH as of

Benjamin Young: So that's practical action on somebody who can do both.
which is maybe Stephen again. anyone here know the UNTP bits, especially
the digital identity anchor content is over here.

Dave Longley: Someone who's not on the call today, I don't remember if
Patrick attends these calls, but he might have some input in this area and…

Dave Longley: we can certainly get it off the mailing list as well. Yes.

Benjamin Young: Right. Okay.

Benjamin Young: As in Patrick's and Louise. No, you're good. I think we
have two Patrick's, but the active Patrick is the one you're talking about.
So, this is a digital identity anchor demo or one of them. And somebody who
knows both things could give that a look. Okay. Yeah, I may do that one out
of band and not ping Patrick here.

Benjamin Young: Okay, Ted, we got the one by you. Did you want to speak to
this at all?

Ted Thibodeau Jr: No, there's a mute button here somewhere. what is this
one?

Benjamin Young: Multialing attributes need more explicit definitions. …

Ted Thibodeau Jr: Open this two weeks ago. Okay. …

Benjamin Young: it's recent history.

Ted Thibodeau Jr: no, I have no words today. I'm sorry.

Benjamin Young: That was way back in February.

Ted Thibodeau Jr: Back before the dawn of time. I got it.

Dave Longley: Yeah, I think this one might have been about whether you pick
a value out of the output validation field and just one value will do or…

Benjamin Young: You're good.

Dave Longley: whether you must validate all of them. it's something around
getting clarity around how to use the output validation. Uh-huh.

Ted Thibodeau Jr: I'm sorry. No, you're close, Dave, but not at all in the
right direction. no the question is whether a value which can hold an
attribute which can have multiple values assigned should have those in
multiple triples or should have a single triple with commaepparated values.
Right? So if you look at the last paragraph of the opener there is a
definite difference between

Ted Thibodeau Jr: One value of red, And three values of red, white, and
blue.

Dave Longley: I get what you're asking. and…

Benjamin Young: I'm going to bring up this chunk of spec text.

Dave Longley: I'm trying to translate it because it's sort of metaphorical
since the values for output validation I think are themselves objects that
have their own troubles about them. yeah,…
00:40:00

Dave Longley: if we have an example, I think output validation has a schema
type or something along those lines in there,…

Ted Thibodeau Jr: This one says right that it can have it that it's
validation schema.

Ted Thibodeau Jr: It's one or more data schemas and…

Dave Longley: And so,…

Ted Thibodeau Jr: there's got to be some identifier for these schemas. And
that gets even further down the line. is this something that's a plain text
identifier or is this a URI identifier?

Dave Longley: Yeah, I think we probably need to make sure the language
better reflects what we've written down in the examples.

Dave Longley: …

Dave Longley: if we look at the examples I get a certain intuition for
what's expected there and how we formalized it is probably unclear in the
way that you're I think.

Benjamin Young: We do say that it must have an ID and…

Benjamin Young: be a URL identifying the schema file.

Benjamin Young: I don't know if that solves what you're asking. Ed. Mhm.

Ted Thibodeau Jr: It's still the challenge of must be one or…

Ted Thibodeau Jr: more data schemas even if you're identifying them with
URLs.

Dave Longley: Yeah, you're looking for it to say is the value itself one or…

Dave Longley: more or…

Dave Longley: are there one or more actual values to that there are many
triples as opposed to one triple that points to some big bucket of things.
Is that right?

Ted Thibodeau Jr: something like that.

Ted Thibodeau Jr: It's

Benjamin Young: Yeah, the value is not a container of any kind.

Dave Longley: Yeah, we're talking about it being a set of these as opposed
I don't know that that would solve your problem.

Benjamin Young: It's a bag if you want to get particular. It's an RDF bag.

Dave Longley: So, I think someone needs to take a stab at some better
language. we don't want the one single string red, white and blue thing.
That's not what we're looking for. We are saying that if this were to turn
be turned in, expressed as triples, it's going to be some blank node
identifier for recognized two and then it will have several triples. if you
had several output validation values, there would be that blank node would
appear as the subject in many triples where the predicate is output
validation and the value is some or all of those other ids that appear in
the output validation value like that learning commission. URL so it's not
the red, white and…

Dave Longley: blue all in a single string metaphor. they are separate. So
we just need language that makes that a little more obvious.

Benjamin Young: And is that an issue with output validation or…

Benjamin Young: is that an issue with recognized t?

Dave Longley: I think it's with output validation the language that's
causing the confusion is one or…

Benjamin Young: Okay.

Dave Longley: more data schemas as opposed there might be other language
that we can find in one of these other specs that talks about sets or
something. Usually we use sets because we map this to the infraspec and
that's an easier way to do the specification than calling it an RDF bag or…

Benjamin Young: Do we want to make it an actual set in the JSON LD or…

Dave Longley: whatever. I think we only do that when you always want it to
be a set of laurel items even…

Benjamin Young: do we tend to avoid that and make a whole new class?

Benjamin Young: right?

Dave Longley: if there's just one in the set. I don't think that's the case
here and it's probably commonly will just be one.

Dave Longley: So we wouldn't want to go out of our way to force that sort
of structure.

Ted Thibodeau Jr: Yeah, I should be more rigorous in…

Ted Thibodeau Jr: I describe what's going on. the issue is whether
expressing multiple data schemas should be done with a single triple or
multiple data schemas require multiple triples.

Dave Longley: It's multiple triples to reference those data schemas by ID
and then there will be other triples about those schemas themselves using
that ID and…

Ted Thibodeau Jr: Yeah, those are irrelevant.

Dave Longley: the subject.

Ted Thibodeau Jr: It's a question of so there's a subject here which is not
talked about in this little blurb. That subject has a property of output
validation with a value with d value being one or more data schemas. That's
problematic.
00:45:00

Dave Longley: Yeah, the description is talking about it from a JSON
modeling perspective and then how that maps to RDF triples that is a
function of the fact that it's JSON LD and it has a way to map to that and
so the pec and the spec level text is referring to it as a JSON model. So
if you're reading that text as if it's describing RDF, I think it's only
going to be confusing. there's probably something we can do to better make
that to make that more obvious, but what Benjamin is typing into the issue
there is…

Dave Longley: how it would translate into RDF.

Benjamin Young: And I will copy in some better stuff real quick.

Ted Thibodeau Jr: I'm sure I'll reply to whatever goes into it.

Ted Thibodeau Jr: We don't have to solve it this minute.

Benjamin Young: I don't necessarily need to post this,…

Benjamin Young: but I can if that's helpful. it's only when they start
talking back that you need to worry mostly about…

Ted Thibodeau Jr: It's probably better than nothing.

Ted Thibodeau Jr: It'll prompt further conversation from somebody, which
may just be me, but that's all right. I talk to empty rooms all the time.

Benjamin Young: what they're going to say.

Benjamin Young: Is this kind of getting close to the point?

Ted Thibodeau Jr: Yes, I think so.

Benjamin Young: Good periods.

Dave Longley: Don't forget to close all that in triple back text or
something, Benjamin. for GitHub.

Benjamin Young: Yeah, you're not worried about my periods. too much cording
on this keyboard. There we go.

Benjamin Young: And then this is this down here.

Ted Thibodeau Jr: That turtle was fine.

Benjamin Young: I will post this since I took all this time to type it. I
think that's less lack of preset prefixes and everything. It's not a valid
turtle, but whatever. There we go. Now they're prefixless terms. okay.
Don't know if this is helpful. Is turn off.

Benjamin Young: There you go. Okay, cool. That was fun. what else do we
have? Some comments happening up here. no, that wasn't me. That was Dave.

Dave Longley: That was just a comment you asked me to make earlier.

Benjamin Young: Terry, sweet. Look at you checking off your to-do list
items. okay. And we were just looking at 46.

Benjamin Young: Let's pop into 44. This is also you from two weeks ago.
yeah. This one I did peek into. It's a

Ted Thibodeau Jr: Jes and…

Ted Thibodeau Jr: this one is again if it's must be a URL then saying that
URL can be data scheme expressing image data is perfectly fine But it must
be URL or…

Ted Thibodeau Jr: image data.

Benjamin Young: Right. Something like that.
00:50:00

Benjamin Young: For anybody who knows data URLs, this is kind of a softball
pitch because Ted's already done most of the work right there.

Ted Thibodeau Jr: Madness. There are worse things.

Benjamin Young: Or Ted, you can send a PR for your issue pretty much. I
know you like commenting on other people's PRs more than sending them.
Think you're afraid we're all going to fix your grammar, but I'm not sure
that's possible.

Benjamin Young: this is probably I'm gonna ignore 43. The comics are still
there. They're just now in the use cases. That's another lowhanging fruit
thing. Somebody can remove those. There's consensus to take them explain
that output validation requires governance. Okay, he's just missing spec
text if somebody wants to tackle that. and to be clear, we're not going to
be getting a whole ton of time from Mono on this spec in the future. So,
these requests aren't just ambient filler.

Benjamin Young: We do need people to step up and start pring.

Benjamin Young: This is kind of use casey.

Isaac Henderson: I have a doubt regarding this previous one actually the
output validation.

Isaac Henderson: Is it part of so normally these validations are done at
the verifier side right for example or…

Benjamin Young: Yeah. Yeah.

Isaac Henderson: verifier or holder side and should we mention that
explicitly as part of our credential or what is the reason actually why we
have this Okay.

Dave Longley: I think this issue,…

Benjamin Young: to this. God, no. No.

Dave Longley:

Dave Longley: sorry to jump Q. I think this issue is just about putting
text into the spec that says if you're going to issue a verifiable
recognition credential, you need to go through the process of actually
making sure that the schemas that you're saying you want in there are valid
so that when a verifier does go to use it,…

Dave Longley: it's one can do something you weren't expecting them to do.
Yeah. So this is just covering the sort of the soft aspect of if you're
going to issue such a credential and you're going to put out output
validation, make sure the schemas are…

Isaac Henderson: Okay. Yeah.

Isaac Henderson: Mhm. Yeah.

Dave Longley: what you want. You don't just throw a schema in there and
don't check it as the party that's doing the issuing because a verifier
will use that schema. they have no idea. they assume that you've made a
good schema.

Isaac Henderson: Yeah, that's true Yeah. This depends on how when we have
multiple list or in together. So that depends or when we have only one list
then it can also be part of the type or context right for example. or not
really or it can Yeah. Okay.

Dave Longley: So where this particular output validation thing appears on a
particular recognize to action. So if you recognize a particular party to
issue certain credentials then that's where these schemas appear. And we
decided in this spec to use JSON schema for the credentials that are being
issued because we felt like it would cover any format for that can be
expressed in JSON anyway.

Isaac Henderson: So then for example if there's some change in the schema
then it also needs to be reflected in the credential right. So the person
who is maintaining the list they need to also preissue the credential again
or so this needs to be part of the governance for example.

Dave Longley: Yeah, that's right.

Dave Longley: If Yep. and…

Isaac Henderson: Okay. Yeah.

Benjamin Young: Yeah. I think it's mostly about expectation setting,…

Benjamin Young: right?

Dave Longley: And Part of the text around that would be, some people would
still be using the older version. and so you would issue a new one and only
once the old one expires would you know that everyone would have moved on
to the new

Isaac Henderson: Okay. Because for me when I see this list one I feel like
this itself is kind of looking like a list of list right so this is the
kind of list of service providers so not rather pointing to a list so this
is a kind of the first one right for example because here these are the
different credential ids or different service providers or who are
authorized to issue certain ID
00:55:00

Isaac Henderson: or credentials in a university so there's no other extra
list but this is the list which is being maintained by them.

Dave Longley: I think the answer to your question is I'm trying to make
sure I'm interpreting all the things that you're saying the right way.

Isaac Henderson: Okay. Mhm.

Dave Longley: So by ids types of credentials. Yes. those are indirectly
referenced by the schema.

Dave Longley: The schema ID can be whatever you want it to be when you
dreference that will have actual type and…

Isaac Henderson: Mhm. Yeah.

Dave Longley: context information about the credentials in there. And then
at least in this example there could be other ways to link to other lists
and to help deal with scalability and so on but at least in this example
there's some higher level I'm trying to avoid using the word authority
there's some higher level recognizer that has bunch of sub entities that it
recognizes to issue

Isaac Henderson: Okay.

Dave Longley: to associates bachelor's degrees, and so on. And so that
higher level party is the one that has to make sure that those schemas are
correct for…

Dave Longley: what they're putting out there. If that made sense.

Isaac Henderson: Okay. Yeah,…

Isaac Henderson: that makes sense. then this itself is a trust model for
set of known issuers, So, okay, that's fine. So, then this is one aspect
and then the next aspect is referencing different other existing trust list
or it's not trust list or verifiable list. So, these are the two aspects
you're covering as part of this verified Yeah. Mhm.

Dave Longley: And in this one Yes.

Dave Longley: And in this one credential, if we looked at that first
example tech that hang on, we're moving around.

Benjamin Young: Sorry.

Dave Longley: It's all right.

Benjamin Young: First example and this example.

Dave Longley: My In example two in the first credential subject there, the
name of that thing is example example polytechnic university. that we have
another property that's is called recognized in and that could also appear
here and it can list as many of these other lists as you want and…

Isaac Henderson: Yeah. Mhm.

Dave Longley: so all of that happens in the same place. So the bit about
governance should say you're responsible for making sure those lists are
right. You're responsible for making sure the schemas are correct if you
list any of that.

Isaac Henderson: Yeah. Mhm.

Dave Longley: And you do all of that when you issue this credential.

Isaac Henderson: Mhm. Okay.

Benjamin Young: which I think there's some of that right here in examples
Yeah.

Dave Longley: Yeah. It is unfortunate if we don't have an example that puts
both there together because people might get the wrong idea that you have
to choose.

Benjamin Young: Should we make an issue for that?

Dave Longley: Yeah, probably.

Benjamin Young: What was the other one recognized too?

Benjamin Young: And sweet.

Dave Longley: and recognized in.

Benjamin Young: Okay, we are down to two minutes, so I'm going to suggest
we not unccort another genie. anyone have any other thoughts or questions
or things they want to see us discuss on future calls? We did great today.
We got all the way down to the last five or so. we even discussed one of
those. So, really just about four left. Okay. Yeah.

Isaac Henderson: Great. Thank you.

Benjamin Young: Thanks for coming everybody. Isaac, thanks for joining the
group and…

Isaac Henderson: Thank you.

Benjamin Young: hope to see you in future.

Isaac Henderson: Yeah, So, we'll try to join next week.

Benjamin Young: Yeah, also hi Dink and…

Isaac Henderson: Okay,…

Benjamin Young: thanks for coming. I know it's like crazy early where you
are. Thanks for tuning in.

Isaac Henderson: thank you everyone. Have a nice day.

Benjamin Young: All righty.

Isaac Henderson: Thank you. Byebye.

Benjamin Young: Thanks all. Bye.
Meeting ended after 00:59:53 👋

*This editable transcript was computer generated and might contain errors.
People can also change the text after it was created.*