Google Developers Blog

The linked post is itself linked to the API in question: Perspective [0].

The site has a demo where you can slide the "toxicity" from left to right and view the resulting bucket of comments sourced from various topics of discussion (Brexit, Climate Change, US Elections). You can also provide your own snippet and get a rating.

Obviously this kind of tool will sustain a lot of discussion about what "toxicity" is and how a ML system could infringe on speech by applying bias, either from the engineers building and evaluating the system, or from the inherent bias in data that Google themselves have already identified as a major problem. [1] For what it's worth, Perspective's site offers a definition of "toxic": "a rude, disrespectful, or unreasonable comment that is likely to make you leave a discussion." The training dataset was ostensibly built by having humans rate comments on a toxicity scale based on that definition.

It seems as though the idea is to penalize poorly thought-out or inflammatory comments while encouraging in-depth or at least more measured responses. I think we can all agree that that is an attractive system to build: the main question will be if it can be done in a fair way and what latent problems might exist in such a system.

[0] https://www.perspectiveapi.com/

[1] https://developers.googleblog.com/2018/04/text-embedding-models-contain-bias.html

Thanks for the info, sounds like you have a pretty solid tech stack :)

Re Java - If you're looking to maximise compatability, then yeah you should aim to target an older JDK. Virtually all Java projects use at least JDK 8 so that can be a baseline, however many enterprise projects would use closer to JDK 18 at a guess (Google's internally aiming to migrate to 21 in 2024). Generally if there are libraries or features from newer JDKs that you do want to use, I'd say just go for it, since JDK 11, the releases have been yearly (there was a three year gap between JDK 8 and 9) and more incremental.

What I would recommend is using Kotlin rather than Java, Kotlin's completely interoperable with Java, but provides a much nicer development experience. That way Kotlin clients get niceties such as named parameters [1] (which with data classes [2] can pretty well replicate StreamdalClient) [1] and Protobuf DSLs [3] and Java clients still get a first class, completely interoperable API.

No idea what WASM support is like for Java, I suspect it's lagging behind other implementations, however the most popular framework is Teavm.

1: https://kotlinlang.org/docs/functions.html#named-arguments
2: https://kotlinlang.org/docs/data-classes.html
3: https://developers.googleblog.com/2021/11/announcing-kotlin-support-for-protocol.html

Google's models work quite well on my Android phone. I haven't found a use case beyond generating shitposts, but the model does its job pretty well. It's not exactly ChatGPT, but minor things like "alter the tone of this email to make it more professional" work like a charm.

You need a relatively beefy phone to run this stuff on large amounts of text, though, and you can't have every app run it because your battery wouldn't last more than an hour.

I think the real use case for apps is more like going to be something like tiny, purpose-trained models, like the 270M models Google wants people to train and use: https://developers.googleblog.com/on-device-function-calling-in-google-ai-edge-gallery/
With these things, you can set up somewhat intelligent situational automation without having to work out logic trees and edge cases beforehand.

The big story here is the encoder-free part, which I still don't fully understand.

> Vision: We replaced Gemma 4’s vision encoder with a lightweight embedding module consisting of a single matrix multiplication, positional embedding and normalizations.

That's technically encoding, just without using a dedicated model for it like SigLIP? The Developer's Guide elaborates, it's still a 35M layer which I am curious is robust enough. https://developers.googleblog.com/gemma-4-12b-the-developer-guide/

> Small enough to run locally on consumer laptops with 16GB of RAM, it unlocks powerful multimodal and agentic experiences right on your machine.

I am assuming that involves quantization, which due to the quality loss makes that statement somewhat misleading IMO.

IMO the code itself has become much less valuable. Most people in this thread are telling you to stay in the code but I would argue you need to stay current on how to architect a good project. What supporting infra do you need? Did you pick the right language? Did you break the project up into appropriate tasks? You need to become a really great PM.

Learn to wrangle your agent better than everyone else. Don't rely on the chat too much, break up your project into tasks, learn to use sub-agents.

Learn to use the new tools well.

This tool seems obvious but its message is really that what you prompt is profoundly important.

https://developers.googleblog.com/conductor-introducing-context-driven-development-for-gemini-cli/

I could see this being useful for client and patient onboarding in the services and medial sectors respectively. For example:

A potential client providing information for a law-firm regarding their grievance.

A patient filling out the medical questionnaire prior to their first visit to a medical practice.

Rather than having a fully deterministic form, you'd be providing them with forms that adapt to their specific issue. The data can then be intelligently stored both as JSON and a more generic record in an RDBMS.

That's just my initial thoughts.

Google has a similar project called A2UI: https://developers.googleblog.com/introducing-a2ui-an-open-project-for-agent-driven-interfaces/