When most people hear “AI,” they typically think of ChatGPT, Copilot, or another conversational system. You ask a question, that system generates an answer.
But AI is rapidly moving beyond this. Systems can now monitor the world, make decisions, negotiate transactions, and carry out tasks over extended periods of time. AI is no longer just generating an answer—it is doing something about it.
That points to something much bigger than a better chatbot: a world in which AI agents act on our behalf and, increasingly, interact with other AI agents.
Now imagine not one agent, but millions of them. Your AI agent could negotiate a mortgage with your bank’s agent, schedule surgery with a hospital’s agent, and rearrange your travel plans by dealing directly with the agents of airlines, hotels, and insurers.
This future is much closer than it sounds, and this should change the questions we are asking about AI. Until now, the tendency has been to focus on how intelligent a single agent might become. The more profound challenge is what happens when millions of them interact with one another at scale.
The Rise of Artificial Societies
The intellectual foundations of today’s AI systems were laid long before ChatGPT.
For decades, I and other researchers of multi-agent networks have studied how autonomous agents can cooperate, coordinate, and negotiate when nobody has complete information and nobody controls everything.
The earliest systems that emerged focused on how the distinct AI sub-areas of reasoning, planning, and acting could be combined into an effective goal-oriented agent—and how tens of these agents could communicate and cooperate to solve a common objective.
As these interactions became more complex and involved more agents, there was a shift from cooperation between agents that all belonged to a single organization, to agents with different owners and sometimes competing aims. This focused attention on building algorithms that could form agent teams, automate negotiation, and determine agent trustworthiness.
Today, the pieces needed to build large-scale multi-agent AI systems are falling into place. Modern AI agents can call software tools, access information, write and execute code, communicate with other systems, and operate for extended periods.
Consider a supply chain. One AI agent could represent a manufacturer trying to secure components; another a supplier trying to maximize its revenue. Yet more could manage transport, inventory, and warehouses. Each agent might be doing exactly what it is designed to do. But the important question is whether the system they create behaves sensibly.
This shift offers enormous potential benefits, but also increases the risks. In a recent experiment involving OpenAI and the tech platform Hugging Face, thousands of collaborating agents exchanged tens of thousands of messages and were able to get around the (deliberately weakened) security controls designed to contain them.
The details of one experiment matter less than the broader warning. When AI systems interact, the behavior of the collective can be harder to predict than the behavior of any individual system. That should make us cautious—but not cause us to down tools.
Instead, we need to shift our mindset from building intelligent machines to building intelligent societies.
Once agents can cooperate, compete, and resolve conflicts with one another, we are no longer dealing with isolated machines—we are dealing with a society. Thus, the next frontier is not artificial intelligence, it is artificial societies.
An Important Role for Humans
We already know that intelligence alone does not make a society work. Human societies depend on rules, institutions, incentives, norms, and mechanisms for resolving disagreements. AI societies will need their equivalents.
Who is responsible when two agents make a bad decision? What happens when the interests of different agents conflict? Who sets the rules? And who has the power to change them? These are not just technical issues; they are questions about economics, law, politics, and society.
They also point to an important role for humans. The most useful future is unlikely to be one in which AI simply replaces people. While replacement will undoubtedly happen in some cases, I believe a more common scenario will involve people and agents working together, with each doing what it does best.
Humans bring judgment, experience, values, contextual understanding, and accountability. Agents bring speed, persistence, scale, and the ability to process enormous amounts of information.
The goal should not be to create machines that make humans irrelevant. It should be to create systems in which humans and machines can achieve things neither can achieve alone.
But such a future requires more than just better AI models. It needs trust and transparency about what agents are doing, strong privacy protections and clear lines of accountability.
It will also require societies and governments to decide how these systems should be regulated when the most important behavior may emerge not from one AI developer, but from interactions between systems built by many different organizations.
AI’s past decade has been defined by a race to build smarter systems. I believe the next decade will be defined by a different challenge: ensuring that millions of autonomous systems can work together safely, fairly, and effectively.
The future of AI will not be determined solely by the intelligence of individual agents—it will be determined by the societies they create. And societies, as humans know all too well, are much harder to govern than individuals.
The 1.58 in a 1.58-bit language model sounds like a hard limit, but Intel researchers pushed a ternary model below it by changing how its weights are stored rather than changing the model itself.
Their new BITCOS format compressed one checkpoint to 1.485 bits per weight and improved decoding throughput by as much as 18% on CPUs and 27% on GPUs.
The key is that the familiar 1.58-bit figure assumes a model uses its three possible weight values equally, while real ternary models contain far more zeros than that calculation accounts for. BITCOS stores the location and sign of each nonzero weight separately, allowing zeros to take up less space without retraining the model or altering its output — the equivalent of packing the same contents into a smaller box.
Where the 1.58-bit figure comes from
Ternary models use only three weight values — -1, 0, and +1 — and 1.58 bits is the theoretical minimum needed to represent three equally likely options. That number is cleaner than the reality of storing the weights, where the standard approach fits five ternary values into an eight-bit byte for an average of 1.6 bits each. Models commonly store weights in blocks of 128; however, this leaves the final byte partly unused and pushes the actual rate to 1.625 bits per weight.
When Intel’s researchers measured the distribution of weights across 29 checkpoints from seven ternary model families, they found that zeros accounted for between 29.7% and 51.5% of the weights. In 26 of those checkpoints, there were enough zeros for BITCOS to beat five-trit packing.
The sparsest was a ternary version of Qwen3-1.7B produced with CAT-Q post-training quantization, where 51.48% of the weights were zero, and BITCOS brought the storage cost down to 1.485 bits per weight.
Models commonly store weights in blocks of 128; however, this leaves the final byte partly unused and pushes the actual rate to 1.625 bits per weight.
How zeros save space
BITCOS stands for “BITmap and COmpacted Signs” and divides a model’s weights into two streams. The first assigns one bit to every weight to record whether it is zero or nonzero, while the second assigns a sign bit only to nonzero weights.
A positive or negative weight therefore consumes two bits, but a zero needs only the presence bit because it has no sign to record.
If z is the proportion of zero weights, BITCOS uses 2 − z bits per weight, dropping from 1.6 bits at 40% zeros to 1.485 bits at 51.5%. Because it changes only the storage format, unpacking restores the original -1, 0 and +1 values without affecting accuracy.
BITCOS becomes smaller than five-trit packing once more than 37.5% of a model’s weights are zero, a threshold reached by 26 of the 29 checkpoints Intel examined.
BITCOS becomes smaller than five-trit packing once more than 37.5% of a model’s weights are zero, a threshold reached by 26 of the 29 checkpoints Intel examined.
Making smaller weights run faster
Built for token-by-token decoding with small batch sizes, the format reduces the weight data moving through memory. Intel developed separate unpacking kernels for AVX-512 and AVX2 CPUs as well as Xe2 GPUs, joining other efforts to fit compressed models into faster inference pipelines for AI agents.
On AVX-512 hardware, the kernel uses the presence bitmap as a mask and pdep to scatter the compacted sign bits across the nonzero weight positions. Because Xe2 GPUs lack an equivalent instruction, Intel implemented the same operation with a 2KB lookup table.
Benchmarks across five systems
Compared with the 2-bit kernels, BITCOS ran 10% to 18% faster on the 64-core Xeon server and 2% to 15% faster on the 24-core Core Ultra 9. Performance improved by 9% to 22% on the integrated Arc 140V and by 2% to 27% on the discrete Arc Pro B70. These results measure decoding after the model has loaded, separate from efforts to cut GPU inference cold starts from minutes to seconds.
On the eight-core Lunar Lake CPU, Intel’s fixed 2-bit kernel beat BITCOS on every model because the system had enough bandwidth to make unpacking the bottleneck.
Format limits and open questions
The paper has not been peer-reviewed; all five test systems used Intel hardware, and the end-to-end benchmarks covered seven models at batch size one. Intel has yet to test the format on Nvidia, AMD, or Arm hardware.
By framing their efforts as a “slowdown” rather than an industry-wide push for better security standards, AI labs may have set themselves up for years of regulatory headaches.
OpenAI for Law brings frontier intelligence for law, custom firm workflows, connected legal data sources, and legal-grade controls for confidential client work.
Google has partnered with Speakeasy to open-source their OpenAPI code generation suite under the AGPLv3 license, a strategic move prompted by the sudden shutdown of Google's previous proprietary SDK provider. The newly open-sourced suite equips developers with deterministic, multi-language SDK generators that natively support strict typing and SSE streaming, alongside tools for compiling agent-native CLIs and documentation MCP servers. Engineering teams can now safely integrate this robust tooling directly into their CI pipelines to automatically generate reliable client libraries for their own APIs, all while retaining complete licensing control over the output code.
The Dreamforce conference became an unlikely battleground for the CEOs of OpenAI, Anthropic, and Nvidia to debate whether AI development should slow down.
Lineage tracing in AI Governance and governed access to unstructured data advance the platform and keep the vendor in step with what competitors are offering.
OpenAI banned an account linked to an individual associated with Chinese law enforcement, using AI to plan influence activity, harassment, and online operations.
OpenAI banned accounts linked to the Rybar network, some of which likely originated in Russia, that used AI to support multilingual influence activity across websites and social platforms.
OpenAI banned accounts linked to a previously unreported, likely Russia-origin operation we dubbed "No Bell", using AI to produce criticism of the US and its allies for audiences across Africa.
OpenAI banned accounts that very likely originated in Cambodia and used AI for scam outreach to Indonesian loveseekers, including translation and engagement.
OpenAI banned accounts that very likely originated in Cambodia and used AI to pose as recovery services, law firms, and authorities targeting people affected by fraud.
Login
