Has any of the targetted organizations (e.g the Australian government) engaged in legal actions against Anthropic/OpenAI? If not then I'm afraid the situation won't change. Even worse it could send the wrong signal that there is a "legal blur" around this topic.
Would have been great to have that sorted out and fixed before passing the EU AI Act and forcing all content generation providers to embed C2PA manifests in their outputs...
The EU AI act doesn’t force C2PA or any particular standard. Yes many people will use C2PA erroneously, but C2PA is not meant for indicating content was virtually generated, but that it was not modified from origination.
C2PA is fallible if your origin is fallible. SynthID is a better standard for designating something was created with GenAI, though is limited in what it covers. For example, 3D content is currently a poor fit for both SynthID and C2PA. Audio is also imho poorly served.
There are a few things in the works for 3D…audio is an area I’ve tracked less.
But crucially , none of the global regulations require C2PA specifically. And with all synthetic data , you’re really relying on honor system for transparency.
It’s not like the sensor to display pipeline that C2PA and Apple’s Reference Image can provide when enforced in hardware.
In traditional provence use case, you want to prove the image have never edited after it was created from the source. When signature mismatch, it is considered invalid.
For AI use case, you want to proof the image have never touched with AI. C2PA only (kind of) proof the last touch wasn't from AI..
> C2PA only (kind of) proof the last touch wasn't from AI..
Given how bad Google's implementation is, the only thing Google's implementation proves is that someone somewhere on earth owns a Pixel phone... and we'll probably learn that it doesn't even prove that.
I like to contrast how Google has responded to the failure of their implementation with how Nikon responded to the very same sort of failures. (Search for "Nikon" here [0], but -IMO- the whole post is worth reading.)
I think it is: look at the "in" which is likely one token, "strawberry" looks like it is 2x the length of "in". Same for the last word, "ing" seems less compressed than "bear" right before it.
Looking at the first several examples, shorter (one, two, three-) letter words are not stretched to the full ‘fixed’ width. It’s the whitespace around them that is fixed. The only example in the first three screenshots of splitting a word into tokes is ‘vibes’ which turns into ‘vib’ and ‘es’. I’m skeptical of the -ing and -tion words being single tokens as shown.
Very interesting feedback. I'm a Go newbie and the goroutine/channel duality sounds delightful from where I stand, but once again I have no professional experience with Go yet, only sample programs to get used to the language.
One question though: your advice is to write things serially first before moving to concurrency, which for me is general programming common sense, but would you argue that once you start writing concurrent code then channels are not well suited compared to "good old" sync primitives (mutexes, etc.)?
There are a lot of places where channels look like the correct primitive but may actually be overkill. One of my favorite examples is collecting results from a group of goroutines. If you know the number of results up front, you can just define a slice and give each thread an index of the slice to write to (and a waitgroup of course). No channels, no mutexes, and completely thread safe.
Looks like a pretty cool community building great tools with care. Using a functional language for data transforms sounds like a sane idea, haven't played around with it yet but it's definitely on my list now.
However they claim using Haskell for data science is "fast", which doesn't really mean anything until you have numbers to show. A little benchmark with pandas and polars wouldn't hurt I guess.
FWIW, https://duckdblabs.github.io/db-benchmark/ linked to from the readme, every result for "Haskell" shows OOM or undefined error. (Even on the large instance, even with the small input.
> Using a functional language for data transforms sounds like a sane idea, haven't played around with it yet but it's definitely on my list now.
It's been one of the plays that the F# community has also been trying to make (somewhat with a modicum of help from Microsoft's marketing arm, but not enough help from what I've seen) pitching F# as a language close enough to Python to feel familiar and useful to data science but with the performance help of rich ML types and the modern .NET performance ecosystem.
(To my experience: getting "fast" compared to Python seems easy for most functional languages. Getting data science out of Python seems hard for a lot of sociology reasons more than technical ones.)
Depends what you're doing, but it really can have C-comparable speed. [0]
Unoptimised/naive Haskell might be that slow. But that's true of a lot of languages and isn't particularly interesting to me. Java is slow if you do everything the naive way, too.
Java ain't slow even if you do really stupid stuff. Hell, I would even argue that java is the most resistant to stupid code. Some way over-abstracted everything linked data structure will be faster in java than it is in C.
Haskell's most badly optimised type, is the String.
Java's most badly optimised type, is the String.
Both of them need a string-builder pattern, the default operators don't work around things to do the right thing for you. They expect you to understand how data works.
The phrase “tends to” is doing a lot of work here. Inexperienced Haskellers tend to use the singly linked list for everything and that data structure just doesn’t perform in any language.
Very interesting insight on the training process, it's pretty cool to have some experimental justification for why they took these exact steps, what they tried and did not work, etc. Feels a bit less like dark magic.
However I agree the latency argument doesn't hold much value with Jev because it runs on a remote server. Seeing how many open Jev-like models came out recently it would be much more interesting to have a comparison with them.
Great tutorial, technical level and writing rhythm are just perfect (for me at least).
Feels great to read something written with care that doesn't sound like yet another Claude-generated blog post.
Thanks to these projects, what was an innovative-but-closed piece of technology one week ago is now much more accessible. Whether they're in it for fame or not, I couldn't care less!
There already was an alternative a year ago, with a published paper and open weight lmao... all the other projects are literal slop shat out by script kiddies 2 hours after the release of jev, it reminds me of the flappy bird era, depressing
Quite impressed by the energy people are putting into making OSS Jev-like models.
I understand the hype but I wonder: what are the use cases for this kind of model? Could it be used in the context of coding agents, or is it more relevant in totally different situations?
Consider every situation where you "force" an LLM to output only a choice / category, or a set of them. If you have workflows like that, you're now being promised significant cost- and latency reduction.
For coding agents it'd only be useful in a subset of situations. E.g. you could imagine using one to classify bash tool calls into safe and unsafe for example.
To develop a smart ai system for my 2d roguelike platformer?
game has way too many moving system for classic state-machine ai + i cant spare the time to develop it.
its low latency entices me.
> what are the use cases for this kind of model? Could it be used in the context of coding agents
Yeah, it could. The most obvious usage would be to have local fast cheap "feedback" / "control" over a slower more expensive agent (i.e. cc / codex / opencode). Things like "goals" could now be split from a long prompt into "actions" and "verifiers". Where for each action you also produce a verifier. Then after each action you run the verifier w/ this kind of "universal classifier" and decide if the step was done correctly, if it needs follow-up and so on.
Example: implement auth in this repo -> llm_plan() -> for item in plan generate_verifier() -> for item in plan implement() ; verify() ; accept() / followup().
Verifiers could be something like this. take a plan item as input, generate classification questions that might verify the task "is this following project conventions?" | "is this touching files from other tasks?", etc.
You can do that with LLMs, but some things might become cheaper / faster. And you can pretty much use it to check against an ever growing list of conventions. Yours or project specific.
The git repo linked at top has some good examples for email classification for automatic email forwarding to specific departments, along with judging email tone and severity / priority, like for customer service emails.
Edit: The Flipper One is planning to have an LLM acceleration co-processor, and be able to host up to a 4GB VRAM size LLM. One use case they envision in their planning is using the microphone along with text to speech to be able to say, "Create an .ini file for this system with these specs" and the small LLM can do that on-device (its a handheld device) and then the user can use/send/upload that file.
Second Edit: I would love a mini LLM in KiCad or Altium that could take a component datasheet and produce a good footprint and schematic symbol for it.
The big problem is that Jev is only useful when you both:
- need fast response
- can tolerate Jev's mediocrity compared to real frontier models
(I explicitly ignore cost, because if you desperately need a cost-optimized classifier you would just build one)
Outside of fun demos these two rarely come together: if it's critical enough to require sub second speed, then it can't be mediocre.
The reason so many OSS models are being built is that Typesafe team made a ton bombastic claims about Jev being a huge breakthrough, and ML folks are realizing they can build Jev-like model in 2 days instead of 2 years.
Classifiers can be very useful for guiding the agentic loop which is basically a state machine. You have the agent propose a task, write some tests, write code, run tests, tests fail, write more code, go to acceptance, etc. So, a classifier can judge state transitions and decide what the agent should do next for example.
There is an enormous amount of time that goes into ticket and other triaging admin across industries. Its use cases go beyond that, but that alone would save a huge number of person-hours.
I think that beyond marketing this is also a way to collect "AI browsing" trajectories. Not an expert but I think this is the kind of great quality data that can be useful when training LLMs.