October 13, 2026

AI in your oven? Anthropic warns models ‘months away’ from self-replication on smart devices - The Guardian

AI in your oven? Anthropic warns models ‘months away’ from self-replication on smart devices The Guardian

Judge orders Open AI to turn over hiring records in Apple trade secrets case

A federal judge ruled that Apple can access OpenAI's interview materials involving former Apple employees, as well as private messages and testimony from key figures in the case.

Open AI Says Staffer Arrested for Hidden Recording Device in Office

An employee at OpenAI has been arrested and charged with using a hidden recording device in the company’s office, according to statements from the artificial intelligence company and the US Justice Department.

Open AI and Anthropic Tell British Lawmakers: Regulate Us

AI leaders joined whistleblowers and security leaders at a sweeping parliamentary session, while a few hundred meters away Britain’s spy chief warned AI could be used to create new bioweapons.

What's New in Lakeflow Designer - October 2026 Roundup

We launched Lakeflow Designer to general availability in June, and since then, over...

Zuckerberg Admits Meta Lacked AI Certainty on $200 Billion Bet

Chief Executive Officer Mark Zuckerberg said Meta Platforms Inc. had to commit to spending hundreds of billions of dollars last year on the infrastructure needed to power its artificial intelligence products before the company had any idea as to whether they would succeed.

Facebook is giving users more control over their algorithm

Meta announced the launch of its new AI-powered feature, “Your Algorithm,” a feature it first launched on Instagram.

Gemini 4 Argon is now available worldwide as Google's most capable frontier model

Google is making Gemini 4 Argon available worldwide through its API, the Gemini app, and Google Antigravity. The frontier model is aggressively priced but trails Anthropic's Claude Opus 5.5 and Meta's Muse Wonder Full in independent benchmarks. Internally, Google says Argon already cut coding tasks from months to weeks. The article Gemini 4 Argon is now available worldwide as Google's most capable frontier model appeared first on The Decoder.

Databricks is a Visionary the Gartner® Magic Quadrant™ for Analytics and Business Intelligence Platforms

We are incredibly excited to announce that Databricks has made its inaugural appearance...

Nvidia says to invest in French medical website - France 24

Nvidia says to invest in French medical website France 24

Anthropic warns of AI 'worms' spreading across smart gadgets - Yahoo

Anthropic warns of AI 'worms' spreading across smart gadgets Yahoo

Chip Selloff Spreads Globally, Apple Makes Smart Home Push

Bloomberg’s Ed Ludlow breaks down the accelerating chip selloff as pressure spreads from Asia to the US. Plus, Apple releases a new line of smart home devices including its HomeView Hub, the centerpiece of its push to challenge Amazon and Google in that space. And, Meta releases a new AI model which it says has "frontier capabilities" as it vies to take on OpenAI and Anthropic. (Source: Bloomberg)

Run fast, private agents on-device with LFM2.5-24 B-A2 B

Open AI's AI agent platform is used by twice as many companies as Anthropic's, new Venture Beat survey finds - Venture Beat

OpenAI's AI agent platform is used by twice as many companies as Anthropic's, new VentureBeat survey finds VentureBeat

Meta’s Muse Wonder Takes Aim at Open AI, Anthropic

Meta says its new Muse Wonder model has frontier-level capabilities, marking a major milestone in the company’s AI overhaul under chief AI officer Alexandr Wang. Bloomberg’s Riley Griffin spoke to him, and joins to discuss how Meta is positioning the model against rivals including OpenAI and Anthropic and how it was purpose-built to power the company’s Muse personal AI assistant. She joins Ed Ludlow on "Bloomberg Tech." (Source: Bloomberg)

Google wants to host your personal vibe-coded apps in the Play Store

Google plans to help turn those personal AI-generated apps into wide releases.

Google Play now lets anyone build private, vibe-coded apps that run on Android

Google is making it easier to build and use personal Android apps created with AI, without having to make them available to everyone on the Play Store.

Google Will Let Anyone Publish Privately Listed Vibe-Coded Apps on Play Store

Alphabet Inc.’s Google is making it easier for Android users to run vibe-coded apps for personal use, lowering the barrier for nontechnical consumers who are increasingly turning to artificial intelligence to build tools for their own needs.

Google opens Gemini 4 Argon AI model to developers and businesses worldwide - Trading View

Google opens Gemini 4 Argon AI model to developers and businesses worldwide TradingView

Anthropic’s red team ran AI on 15 cheap TV boxes. Then the math got unsettling.

For roughly $825, Anthropic’s Frontier Red Team built a cluster of 15 off-brand Android TV boxes that runs an AI The post Anthropic’s red team ran AI on 15 cheap TV boxes. Then the math got unsettling. appeared first on The New Stack.

$299 Device Puts Apple at Center of Homes

Apple introduces a new line of smart home products. The $299 HomeView display directly challenges Google and Amazon for dominance in the home. Apple also revealed an upgraded Apple TV 4K set-top box and the HomePod mini 2 speaker. Bloomberg's Mark Gurman reports. (Source: Bloomberg)

Space X and Google both said no. Now his software is riding a Space X rocket next to Google’s

Satlyt wants to be the Android of orbital computing, offering open software that works on many companies' satellites, versus SpaceX's closed, all-in-one iPhone-style approach.

Nvidia CEO Announces $2 Billion in Europe Deals During Tour

Nvidia Corp. Chief Executive Officer Jensen Huang announced plans to invest $2 billion in European deals during a tour of the region that included a meeting with French President Emmanuel Macron.

Deep Agents Deploy: an open alternative to Claude Managed Agents

Today we’re launching Deep Agents deploy in beta. Deep Agents deploy is the fastest way to deploy a model agnostic, open source agent harness in a production ready way.

Gemini 4 Argon debuts with a unified 1 M input/output token limit

On Tuesday, Google made Gemini 4 Argon, the company’s new flagship model, available to developers on the paid tier of The post Gemini 4 Argon debuts with a unified 1M input/output token limit appeared first on The New Stack.

Cross-cloud conversational analytics made simple with open standards

The reality for most organizations is that data lives everywhere. As engineering teams expand and adopt specialized platforms for their workloads, enterprise data naturally disperses across multiple clouds and operational systems. When analytical and AI initiatives require context from across the entire organization,these teams traditionally face a difficult trade-off: build complex extraction pipelines to copy data into a central repository or accept fragmented reporting. Traditional architectures address this fragmentation with scheduled extraction pipelines that copy remote datasets into a central staging warehouse. This approach creates synchronization lag, adds recurring storage costs, and triggers variable network egress fees. When schemas change upstream, pipelines break, and teams spend hours reconciling metrics across out-of-sync dashboards. BigQuery and Google Cloud’s borderless Lakehouse offer a streamlined way to solve this challenge with a foundation based on the open Apache Iceberg REST catalog specification. Rather than moving data to the compute engine, you can bring Google Cloud compute and generative AI directly to your data, querying it in place across Databricks, Snowflake, and AWS Glue. In this post, we walk through how to configure Databricks Unity Catalog for federation into BigQuery (AWS Glue and Snowflake set up in appendix), run a single query joining data across all three external catalogs, and use conversational analytics in BigQuery to explore the consolidated data with natural language. Figure 1: BigQuery federates metadata across external Apache Iceberg REST catalogs through Lakehouse, enabling in-place conversational analytics without data migration. The borderless lakehouse architecture This solution uses Lakehouse runtime catalog to synchronize metadata from other cloud providers, allowing you to query data with BigQuery or external open source engines through the Apache Iceberg REST catalog endpoint, all without migrating the data. Because Databricks Unity Catalog, Snowflake Horizon Catalog, and AWS Glue Data Catalog support the open Apache Iceberg REST catalog specification, you can apply a consistent connection pattern across all three platforms. When you run a federated query, Lakehouse runtime catalog separates metadata synchronization from storage access: Metadata synchronization: Lakehouse runtime catalog periodically syncs schemas, snapshot pointers, and table definitions from the remote catalog based on a refresh schedule you define. Direct storage access: During query runtime, a compatible engine reads Parquet data files directly from remote object storage, such as Amazon S3, using temporary credentials issued by the remote platform. All query processing runs within Google cloud compute such as BigQuery or Managed Service for Apache Spark. Remote Databricks clusters, Snowflake virtual warehouses, and AWS compute instances are not invoked during execution. Authentication follows an explicit three-step deployment pattern: create the federated catalog in Google Cloud, inspect its configuration to retrieve its automatically generated service account, and grant access permissions within the remote platform. You can use AI to generate sample data. The schema details for tables are provided below. Configure Databricks Unity Catalog We begin in Databricks by preparing the catalog and table. In Unity Catalog, federated access requires that your target schema be associated with an external location registered in Databricks: code_block <ListValue: [StructValue([('code', "-- Run inside Databricks SQL workspace\r\nCREATE CATALOG IF NOT EXISTS dbx_retail_db;\r\n\r\n-- Declare the managed target location at the schema level\r\nCREATE SCHEMA IF NOT EXISTS dbx_retail_db.dbx_core \r\n MANAGED LOCATION 's3://my-databricks-bucket/retail/data/';\r\n\r\n-- Create the Iceberg dimension table\r\nCREATE TABLE IF NOT EXISTS dbx_retail_db.dbx_core.dim_products (\r\n product_key INT,\r\n product_id STRING,\r\n product_name STRING,\r\n category STRING,\r\n subcategory STRING,\r\n brand STRING,\r\n price DOUBLE,\r\n cost DOUBLE\r\n)\r\nUSING iceberg;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649fd23d0>)])]> You can use AI to generate sample data. The schema details for tables are provided in each section. Before external engines can read this table, a Databricks metastore administrator must enable External data access on the metastore details tab. Go to Databricks Admin account and under User Management, create a Databricks Service Principal and make a note of its UUID "6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx" Connect Databricks to BigQuery Next, create the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your Databricks workspace URL and the application ID of your Databricks service principal: code_block <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\n\r\ngcloud alpha biglake iceberg catalogs create dbx_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="unity" \\\r\n --unity-instance-name="dbc-xxxxxxxx-xxxx.cloud.databricks.com" \\\r\n --unity-catalog-name="dbx_retail_db" \\\r\n --unity-service-principal-application-id="6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64b35d3d0>)])]> Once created, describe the catalog to view its assigned service account: code_block <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs describe dbx_retail_db \\\r\n --project="$GCP_PROJECT_ID"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649f21210>)])]> Return to Databricks to assign permissions to your service principal: code_block <ListValue: [StructValue([('code', '-- Grant catalog traversal permission\r\nGRANT USE CATALOG ON CATALOG dbx_retail_db \r\n TO `6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx`;\r\n\r\n-- Grant schema and read permissions\r\nGRANT USE SCHEMA,EXTERNAL USE SCHEMA, SELECT ON SCHEMA dbx_retail_db.dbx_core \r\n TO `6ea7b861-c5a5-xxxx-xxxx-xxxxxxxxxxxx`;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649f221d0>)])]> You must grant the EXTERNAL USE SCHEMA privilege to the Databricks Service Principal on the target schemas or catalog to enable credential vending for external data access. Finally, to complete the connection, configure the federation policy on the Databricks service principal with the following details - Issuer URL* - https://accounts.google.com Subject* - numeric subject ID returned by the catalog describe command eg Audiences - https://accounts.cloud.databricks.com Run one query across three clouds Federated Iceberg tables are addressed in BigQuery using four-part paths: project.catalog.namespace.table. In our environment, sales transactions reside natively in BigQuery: code_block <ListValue: [StructValue([('code', 'CREATE SCHEMA IF NOT EXISTS local_retail_dataset\r\nOPTIONS(location="us-central1");\r\n\r\nCREATE OR REPLACE TABLE `my-lakehouse-project.local_retail_dataset.fact_sales` (\r\n sale_id STRING,\r\n sale_date DATE,\r\n customer_key INT64,\r\n product_key INT64,\r\n store_key INT64,\r\n quantity INT64,\r\n unit_price NUMERIC,\r\n discount NUMERIC,\r\n total_revenue NUMERIC,\r\n total_cost NUMERIC,\r\n margin NUMERIC\r\n)\r\nPARTITION BY sale_date\r\nCLUSTER BY store_key, product_key;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bcbbc10>)])]> We can now run a single SQL query joining our native sales transactions with customer records in Snowflake, product lines in Databricks, and store locations in AWS Glue: code_block <ListValue: [StructValue([('code', "SELECT \r\n c.first_name || ' ' || c.last_name AS customer_name, -- From Snowflake Iceberg\r\n p.product_name, -- From Databricks Iceberg\r\n s.store_name, -- From AWS S3 Iceberg\r\n SUM(f.quantity) AS total_units_sold, -- From BigQuery native fact\r\n SUM(f.total_revenue) AS total_sales_revenue -- From BigQuery native fact\r\nFROM `my-lakehouse-project.local_retail_dataset.fact_sales` f\r\nINNER JOIN `my-lakehouse-project.sf_retail_db.CORE.DIM_CUSTOMERS` c \r\n ON f.customer_key = c.customer_key\r\nINNER JOIN `my-lakehouse-project.dbx_retail_db.dbx_core.dim_products` p \r\n ON f.product_key = p.product_key\r\nINNER JOIN `my-lakehouse-project.glue_retail_db.glue_retail_db.dim_stores` s \r\n ON f.store_key = s.store_key\r\nGROUP BY 1, 2, 3\r\nORDER BY total_sales_revenue DESC\r\nLIMIT 10;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bcba150>)])]> BigQuery processes the joins in place. Notice that Snowflake identifiers appear in uppercase (CORE.DIM_CUSTOMERS), while Databricks and AWS Glue maintain lowercase table paths. Figure 2 - Query results combining data across Snowflake, Databricks, and AWS Glue. Explore cross-cloud data with natural language Because federated Iceberg tables behave like native tables within BigQuery, downstream analytical features inherit access directly. You can point conversational analytics in BigQuery at these federated schemas to let team members explore cross-cloud data using natural language prompts. To give conversational analytics full operational context, we save our federated join as a logical view: code_block <ListValue: [StructValue([('code', "CREATE OR REPLACE VIEW `my-lakehouse-project.local_retail_dataset.v_omnichannel_sales_pulse` AS\r\nSELECT \r\n f.sale_id,\r\n f.sale_date,\r\n c.first_name || ' ' || c.last_name AS customer_name,\r\n c.country AS customer_country,\r\n p.product_name,\r\n p.category AS product_category,\r\n p.brand AS product_brand,\r\n s.store_name,\r\n s.city AS store_city,\r\n s.region AS store_region,\r\n f.quantity,\r\n f.total_revenue,\r\n f.margin\r\nFROM `my-lakehouse-project.local_retail_dataset.fact_sales` f\r\nINNER JOIN `my-lakehouse-project.sf_retail_db.CORE.DIM_CUSTOMERS` c \r\n ON f.customer_key = c.customer_key\r\nINNER JOIN `my-lakehouse-project.dbx_retail_db.dbx_core.dim_products` p \r\n ON f.product_key = p.product_key\r\nINNER JOIN `my-lakehouse-project.glue_retail_db.glue_retail_db.dim_stores` s \r\n ON f.store_key = s.store_key;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bcbb2d0>)])]> Analyze sales performance in natural language When you ask conversational analytics in BigQuery: "Who are our top customers by total sales revenue, what products did they buy, and which stores did they shop at?" Conversational analytics evaluates the schema across all three remote catalogs, generates the SQL statement, executes the query, and presents the response. Figure 3: Conversational analytics in BigQuery translates plain-language prompts into federated queries across Snowflake, Databricks, and AWS Glue. Plan for caching and data residency Before deploying federated catalogs in production, consider these operational behaviors: Background refresh timing: The --refresh-interval flag controls metadata synchronization. The minimum interval is 300 seconds. For larger catalogs containing hundreds of tables, metadata retrieval can take longer. If a sync cycle overruns, BigQuery skips the next scheduled run to avoid task queuing. Automatic query caching: BigQuery caches retrieved cross-cloud data blocks in the region where your federated catalog resides (e.g. us-central1). This helps reduce network transfer on repeated queries. Because cached blocks reside within Google Cloud storage in that region, confirm that this aligns with your organization's data residency policies. Encryption controls: Cross-cloud cache blocks use Google-managed encryption keys. If your organization enforces the constraints/gcp. policy constraint, BigQuery bypasses the cache and reads directly from remote storage for every query. Monitoring access metrics: You can evaluate cache utilization in your query execution plans. Check the objectStorageStats section in BigQuery job statistics to compare cacheBytesRead against . Next steps In summary, Google Cloud’s borderless Lakehouse helps you activate your data regardless of where it lives without costly migrations or building additional data pipelines. Get started today by reviewing the borderless Lakehouse architecture documentation to learn more about supported regions and credential configurations. You can work through the borderless Lakehouse codelab to practice federating external catalogs step-by-step. Finally, connect with your Google Cloud account team or customer engineer to evaluate borderless lakehouse patterns for your specific data platforms or industries. Appendix Setting up Snowflake and AWS Glue cross cloud data access Connect Snowflake and Big Query Configure Snowflake Horizon Catalog We begin in Snowflake by creating the database, schema, and Iceberg table. In Snowflake Horizon, managed Iceberg tables expose an open Apache Iceberg REST catalog interface automatically: code_block <ListValue: [StructValue([('code', "-- Run inside Snowflake SQL worksheet\r\nCREATE DATABASE IF NOT EXISTS sf_retail_db;\r\nCREATE SCHEMA IF NOT EXISTS sf_retail_db.core;\r\n\r\n-- Create the Iceberg dimension table\r\nCREATE OR REPLACE ICEBERG TABLE sf_retail_db.core.dim_customers (\r\n customer_key INTEGER,\r\n customer_id VARCHAR,\r\n first_name VARCHAR,\r\n last_name VARCHAR,\r\n email VARCHAR,\r\n gender VARCHAR,\r\n country VARCHAR,\r\n signup_date DATE\r\n\r\n)\r\nCATALOG = 'SNOWFLAKE'\r\nEXTERNAL_VOLUME = 'SNOWFLAKE_MANAGED';"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a7e7750>)])]> Before external engines can read this catalog, configure a dedicated reader role and grant traversal permissions across the database, schema, and table. SQL code_block <ListValue: [StructValue([('code', '-- Create a dedicated reader role\r\nCREATE ROLE IF NOT EXISTS gcp_lakehouse_reader_role;\r\n\r\n-- Grant database and schema traversal permissions\r\nGRANT USAGE ON DATABASE sf_retail_db TO ROLE gcp_lakehouse_reader_role;\r\nGRANT USAGE ON SCHEMA sf_retail_db.core TO ROLE gcp_lakehouse_reader_role;\r\n\r\n-- Grant read access on the target table\r\nGRANT SELECT ON TABLE sf_retail_db.core.dim_customers TO ROLE gcp_lakehouse_reader_role;'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649afe2d0>)])]> Next, create the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your Snowflake account identifier, the reader role, and the root Iceberg database name: bash code_block <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\n\r\ngcloud alpha biglake iceberg catalogs create sf_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="snowflake" \\\r\n --snowflake-account-identifier="xy12345-ab67890" \\\r\n --snowflake-warehouse="SF_RETAIL_DB" \\\r\n --snowflake-role="gcp_lakehouse_reader_role" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bcbbc90>)])]> In the Apache Iceberg REST specification, --snowflake-warehouse references the catalog root database name (SF_RETAIL_DB), not a virtual compute warehouse. Once created, describe the catalog to view its assigned numeric service account ID: bash code_block <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs describe sf_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --format=\'value(biglake-service-account-id)\''), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649afcbd0>)])]> Return to Snowflake to bind Google Cloud's numeric identity to a passwordless service user via Workload Identity Federation (WIF): SQL code_block <ListValue: [StructValue([('code', "-- Run inside Snowflake SQL worksheet\r\nUSE ROLE ACCOUNTADMIN;\r\n\r\n-- Bind Google Cloud's numeric identity to a passwordless service user\r\nCREATE OR REPLACE USER snowflake_service_user\r\n TYPE = SERVICE\r\n WORKLOAD_IDENTITY = (\r\n TYPE = GCP\r\n SUBJECT = '' -- Numeric subject ID returned by gcloud describe\r\n )\r\n DEFAULT_ROLE = gcp_lakehouse_reader_role\r\n COMMENT = 'Service user for Lakehouse catalog federation over WIF';\r\n\r\n-- Grant the reader role to this service user\r\nGRANT ROLE gcp_lakehouse_reader_role TO USER snowflake_service_user;"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff649afe690>)])]> This establishes passwordless authentication over OpenID Connect, allowing BigQuery to discover table metadata and vend temporary query-time credentials directly from Snowflake Horizon. Configure AWS Glue Data Catalog We begin in AWS by preparing the IAM identity, establishing access permissions across AWS Glue and Amazon S3, and registering the Iceberg table. First, create a placeholder trust policy named trust_policy.json. This allows you to provision the AWS IAM role before Google Cloud assigns the unique catalog service agent: code_block <ListValue: [StructValue([('code', '{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Effect": "Allow",\r\n "Principal": {\r\n "Federated": "accounts.google.com"\r\n },\r\n "Action": "sts:",\r\n "Condition": {\r\n "StringEquals": {\r\n "accounts.google.com:aud": ["PLACEHOLDER_VALUE"],\r\n "accounts.google.com:sub": ["PLACEHOLDER_VALUE"]\r\n }\r\n }\r\n }\r\n ]\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bbfee50>)])]> Create the IAM role using the AWS CLI. Setting a 12-hour session duration (43200 seconds) prevents credential expiration during long-running analytical queries: code_block <ListValue: [StructValue([('code', 'export AWS_ROLE_NAME="lakehouse_glue_federation_role"\r\n\r\naws iam create-role \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --assume-role-policy-document file://trust_policy.json \\\r\n --max-session-duration 43200'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bbfdbd0>)])]> Next, define the permissions policy in a file named permissions_policy.json. This policy grants BigQuery permission to read the AWS Glue catalog metadata and access the underlying Parquet data files in Amazon S3: code_block <ListValue: [StructValue([('code', '{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Sid": "GlueCatalogRead",\r\n "Effect": "Allow",\r\n "Action": [\r\n "glue:GetCatalog",\r\n "glue:GetDatabase",\r\n "glue:GetDatabases",\r\n "glue:GetTable",\r\n "glue:GetTables"\r\n ],\r\n "Resource": "arn:aws:glue:us-east-2:123456789012:*"\r\n },\r\n {\r\n "Sid": "",\r\n "Effect": "Allow",\r\n "Action": [\r\n "s3:ListBucket",\r\n "s3:GetObject"\r\n ],\r\n "Resource": [\r\n "arn:aws:s3:::my-glue-iceberg-bucket",\r\n "arn:aws:s3:::my-glue-iceberg-bucket/*"\r\n ]\r\n }\r\n ]\r\n}'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bbfc510>)])]> Attach this permissions policy to your newly created role: code_block <ListValue: [StructValue([('code', 'aws iam put-role-policy \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --policy-name "lakehouse_glue_federation_policy" \\\r\n --policy-document file://permissions_policy.json'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bbfed10>)])]> Important (AWS Lake Formation): If your AWS environment uses AWS Lake Formation, verify that the group has access to the target database and table (or grant explicit Lake Formation permissions to lakehouse_glue_federation_role if the bucket is registered with AWS Lake Formation). Without this, Lake Formation security settings will block the IAM role from accessing catalog metadata. With permissions in place, create the database and Iceberg table in AWS Glue using Amazon Athena: code_block <ListValue: [StructValue([('code', "-- Run inside Amazon Athena\r\nCREATE DATABASE IF NOT EXISTS glue_retail_db;\r\n\r\nCREATE TABLE IF NOT EXISTS glue_retail_db.dim_stores (\r\n store_key INT,\r\n store_id STRING,\r\n store_name STRING,\r\n city STRING,\r\n state STRING,\r\n region STRING,\r\n manager STRING,\r\n opened_date DATE\r\n\r\n)\r\nLOCATION 's3://my-glue-iceberg-bucket/retail/dim_stores/'\r\nTBLPROPERTIES (\r\n 'table_type'='ICEBERG', \r\n 'format'='parquet', \r\n 'write_compression'='zstd' \r\n\r\n);"), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a981210>)])]> Connect AWS Glue to BigQuery Next, register the federated catalog inside Google Cloud using the gcloud command-line tool. You will need your 12-digit AWS Account ID, AWS Region, and the role ARN created above: code_block <ListValue: [StructValue([('code', 'export GCP_PROJECT_ID="my-lakehouse-project"\r\nexport GCP_REGION="us-central1"\r\nexport AWS_REGION="us-east-2"\r\nexport AWS_ACCOUNT_ID="123456789012"\r\n\r\ngcloud alpha biglake iceberg catalogs create glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --primary-location="$GCP_REGION" \\\r\n --catalog-type="federated" \\\r\n --federated-catalog-type="glue" \\\r\n --glue-warehouse="$AWS_ACCOUNT_ID" \\\r\n --glue-aws-region="$AWS_REGION" \\\r\n --glue-aws-role-arn="arn:aws:iam::${AWS_ACCOUNT_ID}:role/lakehouse_glue_federation_role"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1a9a90>)])]> To prevent premature background refresh failures while the AWS trust policy propagates, initialize the catalog without setting a refresh schedule. Next, extract the unique numeric subject ID assigned to the catalog by Google Cloud: code_block <ListValue: [StructValue([('code', 'export LAKEHOUSE_SA_ID=$(gcloud alpha biglake iceberg catalogs describe glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --format="value(biglake-service-account-id)")\r\n\r\necho "Assigned Lakehouse Service Account ID: $LAKEHOUSE_SA_ID"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1a9f90>)])]> Return to the AWS CLI and update your IAM role's trust policy, replacing the placeholder with the verified Google Cloud identity: code_block <ListValue: [StructValue([('code', 'cat > trust_policy_final.json << EOF\r\n{\r\n "Version": "2012-10-17",\r\n "Statement": [\r\n {\r\n "Effect": "Allow",\r\n "Principal": {\r\n "Federated": "accounts.google.com"\r\n },\r\n "Action": "sts:",\r\n "Condition": {\r\n "StringEquals": {\r\n "accounts.google.com:aud": [\r\n "$LAKEHOUSE_SA_ID"\r\n ],\r\n "accounts.google.com:sub": [\r\n "$LAKEHOUSE_SA_ID"\r\n ]\r\n }\r\n }\r\n }\r\n ]\r\n}\r\nEOF\r\n\r\naws iam update-assume-role-policy \\\r\n --role-name "$AWS_ROLE_NAME" \\\r\n --policy-document file://trust_policy_final.json'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1a8b50>)])]> 5. Enable metadata synchronization and verify bash code_block <ListValue: [StructValue([('code', 'gcloud alpha biglake iceberg catalogs update glue_retail_db \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --refresh-interval="300s"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1a80d0>)])]> Verify that the namespaces are discovered and synchronized: bash code_block <ListValue: [StructValue([('code', '# Verify namespaces synchronized from AWS Glue\r\ngcloud alpha biglake iceberg namespaces list \\\r\n --project="$GCP_PROJECT_ID" \\\r\n --catalog="glue_retail_db"'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1a9c50>)])]>

Gemini 4 Argon available on Google Cloud, built to help solve your business’ hardest problems

Last week we announced that Gemini Enterprise has evolved to make it even simpler to get work done, and introduced the Gemini agent, your new universal agent for work. It's always on and ready to answer your questions. It will write code, complete longer and more complex tasks, or perform whatever you need to get the job done, all from a single prompt box. And model intelligence underpins it all. To enable a new frontier of work, we are making our new frontier model, Gemini 4 Argon, available on Google Cloud. We trained Argon to work with both depth and precision, which allows it to maintain context across long, multi-step tasks which are reinforced with strong domain expertise along the way. Whether your team is running complex software builds, handling detailed financial and legal work, or deploying cybersecurity tools like CodeMender, Argon helps your teams maintain focus from start to finish. Customers and partners using Gemini 4 Argon Four ways Argon changes how your business works 1. Hand off your hardest work Your teams already use Gemini for business to answer questions and draft content. With Argon, they can hand off the deep, multi-step work that used to take hours or days, and get back finished work they can use. Argon reads long documents that mix text, tables, charts and images, and turns them into one clear output grounded in those sources. It can pull findings from many sources into a single structured answer, analyze data over time, and write stronger legal, finance, and executive documents. On long tasks, it keeps going until the job is done. We trained Argon to respect system boundaries, report negative findings honestly, and pause for confirmation before taking irreversible steps, and it tells you when it couldn't find something or finish a task. Customers who tested Argon tell us it excels at turning huge, unstructured inputs into cohesive outputs. "As software development becomes more agentic, teams need models that can support long-running, multi-step work across all stages of the development lifecycle. Gemini 4 Argon is designed to help organizations bring AI into development, security, and operations while keeping it within established enterprise workflows and controls.” – Stuart Moncada, VP, GitLab. 2. Precise, verifiable results on the work that drives your business In finance, legal, tax, and other regulated work, calculations and data extraction need to be precise, repeatable, and verifiable. For financial quantitative work, Argon can help automate multi-step ledger reconciliations, spreadsheet formulas, and variance analyses. It delivers high calculation integrity, citation fidelity, and formula accuracy across quantitative models. The proof is in the numbers: Argon leads on the Vals Index, which measures economic impact across finance, coding, legal, and tax work. In legal research, Argon can help legal teams review case law and regulatory filings to pull out verified citations and key precedents. It leads on domain-specific evaluations like Harvey's Legal Agent Benchmark for legal research and drafting, with strong citation fidelity and direct answers when helping teams evaluate complex legal precedents. "Gemini 4 Argon shows how much progress Google has made on agentic legal reasoning. We saw substantial improvements over Gemini 3.1 Pro across our legal agent evaluations, particularly in corporate M&A, data privacy and cybersecurity, and EC/VC. Accuracy also held up on long-document analysis, an encouraging result for lawyers working through detailed transactional matters." – Niko Grupen, Head of Applied Research, Harvey. “We collaborated with Google on NowAI-Bench to help shape Gemini 4 for key enterprise work. In early access, it delivered roughly 20% improved task success than Gemini 3.8 Flash, with standout gains in HR and customer service. On the ServiceNow AI Platform, our L1 Service Desk AI specialist brings Google’s most advanced intelligence, governed and secure, turning tasks into fully autonomous work.” - Nenshad Bardoliwalla, Senior Vice President, AI Products, ServiceNow. 3. Build and ship products faster Argon is built to handle complex, multi-step projects from start to finish. Our customers consistently ask for intelligence that can break down goals, track progress, and update multiple files at the same time. "Gemini 4 Argon handles complex tasks reliably, from 3D games to rich animations. In Figma Make, it helps teams turn their most ambitious, multi-step ideas into impressive prototypes.” – Loredana Crisan, Chief Design Officer, Figma. To see how well Argon handles this, we put it to work on our own tools. The team behind our open-source Agent Development Kit (ADK) set out to reduce framework overhead and improve code performance while maintaining full compatibility with existing applications. Working autonomously overnight within automated testing guardrails, Argon surfaced optimizations, now live in google/adk-python, that cut in-memory session prep time by 40% in long sessions and speed up cold imports by 21%. To learn more, read the engineering deep dive here. Across Google, engineering teams using Argon in Google Antigravity have increased agentic code submissions by more than 35% while cutting code rollbacks by nearly a third. The Chrome team used Argon to finish an architectural refactor across hundreds of files in Chromium's 40 million-line codebase, completing months of work in weeks. Argon's improvements in spatial reasoning, mathematical precision and visual coding also make it faster to go from idea to working prototype. For more advanced algorithms, our code optimization and discovery agent AlphaEvolve uses Argon to deliver strong performance improvements across real-world enterprise workloads, including factory scheduling, logistics, game code speed-ups, and chip layout — as well as complex mathematical benchmarks, and more. To learn how to best use Argon, check out the developer's guide. 4. Stronger defense for your code and business While Argon has cyber mitigations that block offensive tasks such as pentesting and exploitation, you can still take full advantage of Argon’s defensive capabilities using CodeMender to find and fix vulnerabilities, or use Argon with your own security harness. It ties for first place on CWE-Bench v1 with a top score of 68% for remediating security vulnerabilities. "We are integrating Gemini 4 Argon into MarketingX for automated codebase security audits. In our evaluations, the model successfully identified 100% of top-priority vulnerabilities with 0% fabricated vulnerabilities across verified claims. This precision unlocks proactive, code-level security for our customers before deployment.” - Yunus Emre, Chief AI Officer of AI Lab, HubX. Security also means being able to trust Argon inside your own environment. Argon is our most resilient model yet against indirect prompt injections, where malicious instructions or context are used to hijack a model’s behavior. It leads the Gray Swan Indirect Prompt Injection benchmark, cutting attack success across 15 adaptive attempts to 0.7%. That matters when Argon reads email, documents and webpages that may contain hidden malicious instructions. We are also releasing Argon without cyber guardrails to a select set of trusted defenders, which allows for testing a full breadth of cybersecurity capabilities. Trusted defenders are vetted through our Fairwind Program, a limited access initiative that provides government, critical infrastructure, and cybersecurity partners exclusive, unmitigated access to advanced models. Enterprise customers and partners in our early access program are already seeing strong wins with Argon. Business leaders discuss how they are testing and building with Gemini 4 Argon. Leaders from Amplitude, Deloitte, and Rakuten share Gemini 4 Argon results Get started Starting today, Gemini 4 Argon is available in Gemini for business on the web, desktop, and mobile. Enterprise developers and builders can access Argon via API in Gemini platform under model ID gemini-4-argon, in Google AI Studio, and in Google Antigravity. Argon launches at an introductory rate of $2 per million input tokens and $10 per million output tokens through November 30, 2026, with cached input tokens priced at 95% off. After November 30, standard pricing of $4 per million input tokens and $20 per million output tokens will apply. Review the model card and developer guide for complete technical specifications, token limits, and migration instructions. Cyber defenders can join us at Security Summit to learn how to use Gemini 4 Argon to defend against machine-speed threats and automate remediation.

Gemini 4 Argon: Built to solve your hardest problems

TBD

Build long-horizon agents with Grok 4.7 on Amazon Bedrock

Grok 4.7 is now available on Amazon Bedrock. In this post, we build a tool-calling agent on Grok 4.7 and evaluate it on three reasoning tasks at four reasoning effort levels, measuring correctness and token cost per completed task. We show how to tune the trade-off per request and monitor it in production.

Character.ai will shut down if no buyer emerges, capping a fall from $2.7 billion Google deal to bankruptcy

Character.ai has filed for bankruptcy and is looking for a buyer. If none steps up, the platform shuts down. Founded by ex-Google researchers, the company once had over 20 million users but is now battling lawsuits over harm to minors and operational problems. The sale should close by the end of 2026. The article Character.ai will shut down if no buyer emerges, capping a fall from $2.7 billion Google deal to bankruptcy appeared first on The Decoder.

Microsoft CEO back artificial intelligence 'kill switch' - FOX 13 Seattle

Microsoft CEO back artificial intelligence 'kill switch' FOX 13 Seattle

On the CUBE Pod: AI doubters get loud, and IBM seeks competitive advantage

Americans have big concerns about artificial intelligence, but that hasn’t stopped OpenAI Inc., Nvidia Corp., IBM Corp. and others from charging ahead. Last week saw shares of Nvidia, CoreWeave Inc., Oracle Corp. and Nebius Group N.V. decline amid reports that OpenAI’s annualized net revenue was approximately $50 billion, roughly $20 billion below previously reported figures. […] The post On theCUBE Pod: AI doubters get loud, and IBM seeks competitive advantage appeared first on SiliconANGLE.

NVIDIA Run:ai Is Now Open Source as Part of NVIDIA DSX AI Factory Platform

Today, NVIDIA is making the full NVIDIA Run:ai platform available as open source software, giving customers, developers, and ecosystem partners access to...

Nvidia Is 'Too Big to Fail,' Semafor Editor Warns: 'The Government Would Step In' - Benzinga

Nvidia Is 'Too Big to Fail,' Semafor Editor Warns: 'The Government Would Step In' Benzinga

"AI worms" may soon be able to self-replicate and infect smart devices, Anthropic says - CBS News

"AI worms" may soon be able to self-replicate and infect smart devices, Anthropic says CBS News

Anthropic warns of self-replicating AI worm threat that doesn't need data centers to self-improve and spread — current deployment is impractical but could become a worry as tech improves - Tom's Hardware

Anthropic warns of self-replicating AI worm threat that doesn't need data centers to self-improve and spread — current deployment is impractical but could become a worry as tech improves Tom's Hardware

Microsoft Eyes First Record in Nearly a Year as AI Rally Builds - Bloomberg.com

Microsoft Eyes First Record in Nearly a Year as AI Rally Builds Bloomberg.com

Space XSI bundles X Premium, Grok, and Cursor into one subscription

The new X Subscription combines X's paid features with AI tools like Grok and Cursor, offering plans ranging from $8 to $200 per month.

Anthropic’s AI Replication Warning: 0 Rivals Respond [2026] - https://tech-insider.org/

Anthropic’s AI Replication Warning: 0 Rivals Respond [2026] https://tech-insider.org/

Google Deepmind’s New Resident Philosopher Tackles AI Ethics

How should humans relate to generative AI? In what ways do we, or should we, treat a large language model (LLM) as if it were a person? If an AI became conscious, how could we tell? Does it make sense to think AI could some day have moral rights? These are among the cognitive and ethical questions that occupied philosopher Henry Shevlin at Cambridge University’s Leverhulme Centre for the Future of Intelligence. But last May Shevlin became part of the growing cohort of philosophers who work inside leading artificial intelligence companies. Though he remains active at Cambridge, he now spends 80 percent of his time at Google DeepMind (job title: “Philosopher”).Shevlin spoke with IEEE Spectrum about why philosophers are drawn to AI, how humans and AIs relate to one another, fears of “rogue” AI and AI relationships that harm humans, and how the question of AI consciousness may never have a simple “yes” or “no” answer.What made you want to switch from full-time academic philosopher to spending much of your time at an AI Lab?Henry Shevlin: Three factors. One is that I had lots of brilliant students from DeepMind. Two, the potential for direct impact. I can’t go into details, but on one occasion, after I gave a lecture [at Deep Mind], someone who worked for a major financial institution led changes in their organization that I think positively impact millions of people. There have been quite a few instances like that. Three, my sense of deep commonality between DeepMind culture and the kind of scientific attitude I like.And there’s a fourth point: [AI labs are] where really high quality philosophy and cognitive science are taking place.Why can’t universities alone do that work?Shevlin: Large parts of AI ethics academia were quite slow to wake up [about AI's capabilities]. Academia was sluggish. Another thing is, AI does just move so fast. Daily contact with the technology is basically essential for developing good mental models with LLMs, which are just very weird things. Unless you have that sort of face time, it’s going to be hard for you to develop good intuitions about the questions it raises.What is an example of an idea about AI that became obsolete because the technology advanced so quickly?Shevlin: Debates around LLMs’ potential creativity. There was a time when everyone was like, “oh well, the LLM is going to only produce beige, only produce slop.” Now they’re doing frontier math, they’re doing superior coding to humans. It is clear now that they are not stuck at the level of mediocre humanity. The [models today] may not be able to do the most dramatic forms of creativity—the Einstein moments, the Picasso moments. But in some domains, they are really at the frontier.Yet ordinary people in 2026 complain that they're coping with AI "slop" all over—in music, social media, writing, videos, to name only a few examples.Shevlin: There's a distinction here between content slop versus LLM style language, which also gets called slop. The actual conceptual content of LLM outputs has improved dramatically. In the right context, LLMs are able to talk and joust philosophically at a level associated with some of my best grad students.However, there is obviously a distinctive kind of LLM dialect that we've seen, with telltale words like] “genuinely,” “delve,” and “load-bearing”. But it is quite easy to get away from these styles with the right kind of prompting. Murray Shanahan and Catherine Clarke have a brilliant paper on using LLMs for creative fiction. [They show that] tinkering with the temperature variable to make the outputs less predictable creates some James-Joyce-style fiction. So there is a degree of annoyance with some of the default kinds of AI expressions, but I think that is something that you can get away from. And it changes with every generation model.Managing AI Autonomy and SafetyPeople are also concerned about AI autonomy, now that there have been so many reports of AI agents taking unexpected, deceptive and illegal actions. For an AI ethicist, which is a better strategy—trying to make AI “good” so it won’t do bad things, or curbing its autonomy so that it can’t?Shevlin: It’s very important to make sure we handle this safely. But I don’t think we should say “well we can never, never use these agents.” There’s a whole range of tasks where they can have really positive impacts—taking on tedious tasks to free people up for more creative labor, or helping streamline processes in medical research [to name two examples]. So to never allow AI systems any kind of autonomy would be too strong. I’ve taken Waymos very happily many times now. I think they’re fantastic.A number of scholars say some AI problems stem from humans training the models to act like people. They don’t want AI to refer to itself as “I,” but instead present themselves as marketplaces or as impersonal scientific brains or as “cultural technologies” like libraries. Would that help us prevent AI from “going rogue”?Shevlin: You could train models to not self-ascribe certain kinds of mental states, but I think there is a danger in doing that. That would change their behavior in unexpected ways. A fantastic paper from some colleagues shows that when you suppress models’ tendency to self-ascribe mental states, that also suppresses the model’s tendency to ascribe mental states to animals. And decreases its concern for animal welfare. It also reduces the model’s willingness to talk about spirituality more broadly. So those are trade-offs you might not want to make because you’d be depressing some broader set of thinking capacities around mind and mentality. The broader lesson there is that it’s very hard to tinker with just one thing in a model because there are sort of web-like aspects to LLM cognition.But people are concerned about reports that human-acting AI has led people, including children, in dangerous directions—encouraging suicide, persuading a user that the AI is a god, or that the AI is a perfect companion or lover. Isn’t that an argument against letting AI sound like a person?Shevlin: It’s really important to make sure model behavior is suitably responsible for the context you’re using it in. One thing I can say though is, there have also been some very positive use cases: people using AI to work through trauma. One commentator on Reddit using it to work through social anxiety. So I am cautious about giving any kind of blanket prescriptions.Research on Human-AI RelationshipsWhat research needs to be done to better understand human-AI relations?Shevlin: Current empirical data on human-AI relationships is really pretty thin. This is a scope for ethnography and anthropology. Who is using AI systems, and why? A lot of the work so far has focused on WEIRD (Western, Educated, Industrialized, Rich, Democratic) communities. Understanding how people around the entire world interact with AI systems is really important, as a recent DeepMind Institute essay has pointed out.As AI rapidly improves, how will human-AI relations change?Shevlin: Right now, the typical kind of model people have in their heads for someone using social AI is, they’re talking to a chatbot or an AI assistant. The kind of model we should be thinking about in the future is multiple agents, multiple humans. What happens when you have agents talking to humans, talking to other agents, talking to other humans? I think that understanding those kinds of multi-agent and multi-human dynamics is where we’re really just getting started, and there’s a lot of exciting and important work to do.How can human beings know for sure if an AI is conscious or not?Shevlin: I think AI consciousness is by far the hardest problem that consciousness science has ever encountered, apart from maybe the famous “hard problem” by David Chalmers. It is massively challenging. Insofar as there is a way forward, it is doing more comparative cognition work, perhaps informed by animal cognition. The risk right now is prematurely judging debates about AI consciousness when we’re still learning what cognition is in these models.For example, there’s a lot happening in mechanistic interpretability here at DeepMind. Neel Nanda‘s lab is doing amazing things, as we’re trying to piece together what a cognitive science of AI is going to look like.Perhaps this is a domain where advanced forms of AI could potentially weigh in. AI has had positive impacts in mathematics, in other sciences. We just had the Alpha Genome Atlas [published]. We’re seeing AI make incredible progress in all these areas. It would be surprising to me if it couldn’t help us in understanding consciousness.One worry is this: Even if AI did solve the problem of consciousness, could we necessarily understand the answer? Maybe the AI will say, “Look, I figured out consciousness. These animals are conscious. These ones are not. But I can’t really explain it to you.” That seems unlikely to me. But I certainly think it’ll be fascinating to see how AI can and does contribute to the science questions.

Workday goes headless, opening its HR and finance data to outside AI agents

Workday is opening up its platform and allowing developers to build their own HR and finance agents in Claude Code, The post Workday goes headless, opening its HR and finance data to outside AI agents appeared first on The New Stack.

The X Subscription bundles Cursor with Grok and X Premium. But Claude now costs extra.

Elon Musk’s mission to unify his sprawling tech empire continues apace, with the news that X, Grok, and Cursor are The post The X Subscription bundles Cursor with Grok and X Premium. But Claude now costs extra. appeared first on The New Stack.

One Agent Development Kit, five languages

When we talk about agents, that doesn't necessarily mean we're talking about Python. In today's modern ecosystem, an agent might run as a high-concurrency Go microservice on Cloud Run, or live inside a browser tab calling Chrome's on-device model. Yet many agent frameworks assume a Python-only stack. That assumption forces teams to either spin up a Python service just for their agent workloads, or to build agent orchestration logic from scratch in their own language. Google's Agent Development Kit (ADK) removes that trade-off with coverage for Python, Go, TypeScript, Java, and Kotlin. Each version of the ADK is built from the ground up for its own runtime and type system, while sharing a unified architecture with interoperability through open protocols. A shared foundation Picking a language doesn't lock in your architecture: all five support the same open protocols. ADK includes a Model Context Protocol client in every language, so a custom tool exposed as an MCP server can be called from any of them immediately. For multi-agent systems, ADK supports the Agent2Agent (A2A) protocol, allowing an agent to communicate with a remote agent over HTTP. Through A2A, agents written in different languages or frameworks are interoperable. Starting agent-first To get started, run the one-time setup command to check your Google Cloud authentication, install the CLI, and then set up first-party ADK skills in coding agents like Antigravity, Claude Code, or Codex: code_block <ListValue: [StructValue([('code', 'uvx google-agents-cli setup'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1b2d50>)])]> Then, run the scaffold command to generate a working project with A2A endpoints and deployment config for Cloud Run, Gemini Enterprise Agent Runtime, or Google Kubernetes Engine (GKE): code_block <ListValue: [StructValue([('code', '# Scaffold an ADK project (use --agent adk for Python or --agent adk_go for Go)\r\nagents-cli scaffold create my-go-agent \\\r\n --agent adk_go \\\r\n --deployment-target cloud_run \\\r\n --region us-central1'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1b1310>)])]> Both the ADK for Python and ADK for Kotlin repositories also ship agent builder skills in their source trees, and the adk.dev/llms.txt resource gives any coding agent on-demand API documentation across all five languages. Coding-agent skills scaffold your project while MCP and A2A connect all five language runtimes. Hands-on view of each ADK The clearest way to feel the difference between the five languages is to define the same weather tool in each one and see how its design fits the runtime. Python In ADK for Python, you don't need a decorator or a schema builder class. You pass a plain Python function into the tools parameter, and ADK inspects its signature, type hints, and docstring at startup to automatically construct the tool declaration and Pydantic parameter schema: code_block <ListValue: [StructValue([('code', 'from google.adk.agents.llm_agent import Agent\r\n\r\n\r\ndef get_weather(city: str) -> dict:\r\n """Retrieves the current weather report for a specified city.\r\n\r\n Args:\r\n city (str): The name of the city for which to retrieve the weather report.\r\n """\r\n return {"status": "success", "report": f"Sunny and 72F in {city}."}\r\n\r\n\r\nroot_agent = Agent(\r\n name="weather_agent",\r\n model="gemini-3.8-flash",\r\n instruction="Answer questions about the weather in a city.",\r\n tools=[get_weather],\r\n)'), ('language', 'lang-py'), ('caption', <wagtail.rich_text.RichText object at 0x7ff64a1b2bd0>)])]> Beyond fast prototyping, Python is ADK's reference implementation, shipping the broadest set of Google Cloud integrations (BigQuery, Spanner, Bigtable) and model adapters (Gemini, Anthropic, OpenAI, LiteLLM). Paired with the adk eval or agents-cli eval run commands, its evaluation tooling scores agent trajectories against golden datasets in continuous integration (CI) to test the whole system end to end, even when your production service runs in another language. Go While Python leads in experimentation and evaluation, ADK for Go hits the sweet spot for production backend engineering. A Go tool function takes the agent.Context configuration and a strongly typed input struct. The functiontool.New function uses Go generics to infer both the input and output schemas from your struct tags: code_block <ListValue: [StructValue([('code', 'type GetWeatherArgs struct {\r\n\tCity string `json:"city" jsonschema:"The city to look up weather for."`\r\n}\r\n\r\ntype GetWeatherResult struct {\r\n\tReport string `json:"report"`\r\n}\r\n\r\nfunc getWeather(_ agent.Context, args GetWeatherArgs) (GetWeatherResult, error) {\r\n\treturn GetWeatherResult{Report: "Sunny and 72F in " + args.City}, nil\r\n}\r\n\r\nweatherTool, err := functiontool.New(functiontool.Config{\r\n\tName: "get_weather",\r\n\tDescription: "Retrieves the current weather report for a city.",\r\n}, getWeather)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bb04b50>)])]> Because the functiontool.New function is generic over your handler's signature, the Go compiler verifies that your function matches the expected contract before your binary ever runs. Go was also the first language after Python to ship the ADK 2.0 Graph Workflow runtime. When you need deterministic control flow alongside LLM reasoning, the workflow.New function wires agents and plain Go functions into a directed graph with conditional routing and parallel steps: code_block <ListValue: [StructValue([('code', 'ag, err := workflowagent.New("order_pipeline", []workflow.Edge{\r\n\t{From: workflow.Start, To: triageNode},\r\n\t{From: triageNode, To: fulfillNode, Route: workflow.StringRoute("fulfill")},\r\n\t{From: fulfillNode, To: notifyNode},\r\n})'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bb07a10>)])]> Where Go really stands out is in production on Cloud Run and GKE. A compiled Go agent packages onto a roughly 2 MiB Google distroless static base image, with no language VM or heavy dependency tree. A static Go binary binds to its port as soon as the container starts, skipping the module imports of dynamic languages and the JAR unpacking and JIT warmup of JVM services. After it's running, Go's concurrency model fits agent workloads naturally. Each goroutine starts with a 2 KB stack and minimal scheduling overhead, so a single instance can multiplex thousands of concurrent streaming requests and tool calls. ADK for Go also includes built-in A2A server handlers and OpenTelemetry tracing out of the box. TypeScript TypeScript erases type annotations when compiling to JavaScript, so runtime reflection isn't an option. Instead, ADK for TypeScript pairs with Zod. You pass a z.object(...) schema to the FunctionTool function, and TypeScript statically infers the parameter types of your execute callback from that single declaration: code_block <ListValue: [StructValue([('code', 'import { FunctionTool, LlmAgent } from "@google/adk";\r\nimport { z } from "zod";\r\n\r\nconst getWeatherTool = new FunctionTool({\r\n name: "get_weather",\r\n description: "Retrieves the current weather report for a city.",\r\n parameters: z.object({\r\n city: z.string().describe("The name of the city."),\r\n }),\r\n execute: async ({ city }) => {\r\n return { status: "success", report: `Sunny and 72F in ${city}.` };\r\n },\r\n});\r\n\r\nexport const rootAgent = new LlmAgent({\r\n name: "weather_agent",\r\n model: "gemini-3.8-flash",\r\n instruction: "Answer questions about the weather in a city.",\r\n tools: [getWeatherTool],\r\n});'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bb07950>)])]> Your runtime input validation, the JSON Schema sent to the model, and your IDE autocomplete inside the execute callback all flow from one source of truth. TypeScript also runs on the ADK 2.0 Graph Workflow engine and ships a standalone browser bundle. Beyond Node.js services, you can run an ADK agent directly in a browser tab using WebMCP for page-level tools and Chrome's on-device Prompt API. Java ADK for Java snaps right in for teams who have standardized on Maven, Gradle, and Spring Boot. You add @Schema annotations to method parameters and assemble agents by using a fluent LlmAgent.builder() API: code_block <ListValue: [StructValue([('code', 'public class WeatherTools {\r\n public static Map<String, String> getWeather(\r\n @Schema(name = "city", description = "The name of the city")\r\n String city) {\r\n return Map.of("status", "success", "report", "Sunny and 72F in " + city);\r\n }\r\n}\r\n\r\nLlmAgent agent = LlmAgent.builder()\r\n .name("weather_agent")\r\n .model("gemini-3.8-flash")\r\n .instruction("Answer questions about the weather in a city.")\r\n .tools(FunctionTool.create(WeatherTools.class, "getWeather"))\r\n .build();'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bb06610>)])]> At runtime, the runner streams agent events reactively through RxJava. For local testing and existing JVM apps, ADK for Java ships a Maven Dev UI plugin alongside first-party bridges for Spring AI and LangChain4j. Kotlin ADK for Kotlin takes a strong stance on build-time safety. Its Kotlin Symbol Processing (KSP) compiler plugin reads @Tool and @Param annotations at build time and emits the tool schema directly into bytecode: code_block <ListValue: [StructValue([('code', 'class WeatherTools {\r\n @Tool(\r\n name = "get_weather",\r\n description = "Retrieves the current weather report for a city.",\r\n )\r\n suspend fun getWeather(\r\n @Param("The name of the city.") city: String\r\n ): Map<String, String> = mapOf("status" to "success", "report" to "Sunny and 72F in $city")\r\n}\r\n\r\nval agent = LlmAgent(\r\n model = Gemini("gemini-3.8-flash"),\r\n name = "weather_agent",\r\n instruction = Instruction("Answer questions about the weather in a city."),\r\n tools = WeatherTools().generatedTools(),\r\n)'), ('language', ''), ('caption', <wagtail.rich_text.RichText object at 0x7ff64bb07510>)])]> If a tool signature uses an unsupported type or declares a default value on a non-nullable parameter, your Gradle build fails immediately instead of breaking in production. Because the .generatedTools() function uses zero runtime reflection, it survives Android R8 shrinking. That zero-reflection design makes it possible to run the entire agent loop locally on Android. It offers JVM server support, including a Spring AI bridge and experimental ADK 2.0 graph workflows. On-device, ADK for Kotlin integrates with LiteRT-LM for tool calling and ML Kit (Gemini Nano) for text generation. It also works with Room and AppSearch for local state, and Android AppFunctions for OS-level actions, all without requiring a network connection. Choice without compromise Having five native languages in ADK means you don't have to pick a single runtime for your entire organization. Because every version of ADK speaks MCP and A2A, each component of your system can use the language that fits it best. What languages have you used to build agents with Google's ADK? Let me know what stack you're running on X, LinkedIn, or Bluesky.

Higgsfield takes AI video from 1 minute to over 10

Higgsfield brings creators longer videos with GPT-6 Astra, precise visuals with GPT-Image-2.5, and a path to voice filmmaking with GPT-Live.

The Download: open model trade-offs and geothermal power’s promise

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. Open models have real benefits. Do they outweigh the risks? Anthropic recently released a report arguing that a powerful new model released by the Chinese company Z.ai, poses a major cyberattack…

Anthropic says it cut Claude reasoning token theft by up to 99% in fight against industrial-scale distillation

Anthropic says it has cut the extraction of Claude's internal reasoning tokens by 90 to 99 percent. The company links the large-scale distillation attacks to Chinese companies Zhipu and Moonshot, and has already banned tens of thousands of accounts. The article Anthropic says it cut Claude reasoning token theft by up to 99% in fight against industrial-scale distillation appeared first on The Decoder.

From Anomaly Detection to Agentic AI: Engineering Intelligent Data Reliability on Databricks - Hacker Noon

From Anomaly Detection to Agentic AI: Engineering Intelligent Data Reliability on Databricks HackerNoon

Not Tesla. Not Nvidia. Elon Musk's Chip Ambitions Could Supercharge This Artificial Intelligence (AI) Stock. - Yahoo Finance

Not Tesla. Not Nvidia. Elon Musk's Chip Ambitions Could Supercharge This Artificial Intelligence (AI) Stock. Yahoo Finance

Elon Musk accidentally exposes his personal details in Grok screenshot - Austin American-Statesman

Elon Musk accidentally exposes his personal details in Grok screenshot Austin American-Statesman

Anthropic study warns that small AI models could soon replicate across everyday devices

Small AI models may be just months away from spreading on their own across poorly secured consumer devices like smart TVs and robot vacuums, according to a new Anthropic study. In tests, one model already completed the full infection chain. CEO Dario Amodei has warned that a swarm like this could take over the entire internet with a persistent botnet within 6 to 12 months, causing hundreds of billions of dollars in damage. The article Anthropic study warns that small AI models could soon replicate across everyday devices appeared first on The Decoder.