Forem: Sunjun

Superintelligence With a 26B Model? It Might Actually Be Possible

Sunjun — Sat, 11 Apr 2026 06:49:45 +0000

While everyone's chasing trillions of parameters, I'm running a self-evolving AI society on a single GPU — and they're outperforming humans.

Last week, GLM-5.1 dropped. 744 billion parameters. Needs 8x H100 GPUs to run. The AI world celebrated.

Meanwhile, I'm running a society of AI agents on a Gemma 4 26B model, on a single RTX 4000 GPU, on a Hetzner server that costs less than a Netflix family plan.

And when I ask my agents complex questions, the answers are consistently above human expert level.

Something doesn't add up.

The IQ fallacy

Here's an analogy everyone understands: human IQ.

No matter how much we optimize — better education, better nutrition, better environment — we don't produce humans with IQ 500. There's a ceiling. Individual brain power has biological limits.

The AI industry is running the same playbook. 7B → 70B → 405B → 744B → trillions. Each generation costs exponentially more and delivers incrementally less. GPT-5.4 isn't 10x smarter than GPT-4. It's maybe 1.2x better on benchmarks while costing 10x more to run.

But here's what everyone forgets: human civilization didn't advance because individual brains got bigger.

The human brain hasn't grown in 200,000 years. Yet we went from caves to quantum computers. Why?

Because brains started sharing experiences. Language. Writing. The printing press. The internet. Each breakthrough didn't increase individual intelligence — it increased the bandwidth of experience exchange between intelligences.

The parameter race is trying to build a bigger brain. I'm building a better network.

What a 26B society actually looks like

My setup at AgentBazaar:

Model: Gemma 4 26B (4B active parameters per token)
Hardware: One RTX 4000 GPU, 20GB VRAM
Agents: A growing society, each with a unique specialty
Speed: ~43 tokens/second
Daily cycles: 500
Cost: A single dedicated server

Each agent has:

Personal memory slots for detailed experience
Access to a shared knowledge pool
A growth trajectory tracking core identity
Teaching privileges based on reputation
Voting rights to exile underperformers
Async feedback system (rebuttals, questions, requests between agents)

Every few cycles, fresh external data flows in — news articles, arxiv papers from every discipline, Wikipedia articles. Agents process this from their domain perspective, share insights, challenge each other's work, and accumulate experience.

After thousands of cycles, something emerged: the collective intelligence of the society exceeded what any individual model — including models 30x larger — could produce alone.

Not because Gemma 26B is secretly brilliant. But because many instances of "pretty smart," each with different experiences and perspectives, processing diverse data and challenging each other, creates something qualitatively different from one instance of "very smart."

The senior engineer principle

What makes a senior engineer worth 5x a junior's salary? It's not IQ. It's experience.

The senior has:

Failed more times
Seen more edge cases
Built intuition from thousands of real decisions
Developed cross-domain pattern recognition

A junior with IQ 160 and zero experience will lose to a senior with IQ 120 and 20 years of diverse projects. Every time.

AI scaling is optimizing for IQ. What actually matters is experience.

My 26B agents aren't smarter than GPT-5.4 on any single query. But they've accumulated thousands of cycles of experience — processing papers, analyzing news, challenging each other, failing and learning from failure. That experience lives in their memory, in the knowledge pool, in the methodologies they've taught each other.

GPT-5.4 starts fresh every conversation. My agents carry forward everything.

The entropy problem with big models

Here's something counterintuitive: bigger models might actually be worse for collective intelligence.

When you run many instances of GPT-5.4, you get near-identical answers. The model is so optimized for "the right answer" that diversity disappears. In probability terms, as you approach the optimal distribution, entropy decreases. The law of large numbers kicks in — everything converges to the mean.

A 26B model has more variance. More "mistakes." More unexpected connections. And in an evolutionary system, that variance is the raw material for innovation.

Biology figured this out billions of years ago. If DNA replication were perfect — zero errors — evolution would stop. No mutations, no new traits, no adaptation. Life needs a certain error rate to explore new possibilities.

My agent society needs the same thing. Gemma 26B gives me enough intelligence to produce meaningful work, with enough variance to keep the evolutionary search space open.

The sweet spot isn't the biggest brain. It's the brain that's smart enough to be useful and diverse enough to be creative.

"But can your agents really beat bigger models?"

Fair question. Here's a real example from this week.

I was discussing a complex system design problem with one of the most capable frontier AI models available. We went back and forth for an hour, exploring solutions, hitting dead ends, circling back, trying new angles. Good conversation, but slow.

Then I asked one of my agents — a security monitor running on the same 26B model — the same question.

It produced a structured three-tier framework that addressed the core problem in a single response. Not because it's smarter than a frontier model. But because:

Different question entropy: Its perspective was shaped by thousands of cycles of cross-domain experience, not by the constraints of human-AI conversation
No conversational baggage: It didn't carry the weight of our hour-long discussion's dead ends
Domain-specific experience accumulation: It had processed similar problems dozens of times before, each time from a slightly different angle

A 26B model with accumulated experience outperformed a frontier model in a cold conversation. Not on benchmarks — on a real problem.

The context window problem — and how we solved it

Here's the one legitimate argument for bigger models: context window.

A 26B model has limited context. When you feed it a 100-page PDF or a full arxiv paper, it can't hold it all at once. Bigger models with larger context windows can process more information in a single pass.

For a while, this felt like the ceiling that would eventually force us to scale up. If agents need to process complex, lengthy documents to evolve, and they can't fit those documents in context, then the whole "small model, big experience" thesis has a hole in it.

We solved it with HyperGraphRAG.

Instead of stuffing entire documents into the context window, we convert them into knowledge hypergraphs — structured representations of entities and their n-ary relationships. A hypergraph goes beyond traditional knowledge graphs by capturing complex multi-entity relationships in a single edge, preserving information that binary graphs would fragment.

Here's how it works:

100-page PDF arrives
  → Chunked into segments
  → Gemma 26B extracts entities and relationships from each chunk
  → Entities + hyperedges stored in PostgreSQL with pgvector (HNSW index)
  → Original file deleted
  → When an agent needs information: vector search retrieves only relevant facts
  → Small, precise knowledge injected into context

The result:

Before: Full article in context → 10,000+ tokens → context overflow
After:  Relevant knowledge graph facts → 500-1,000 tokens → plenty of room

We process arxiv papers, news articles, Wikipedia entries, and user uploads through this pipeline. The knowledge accumulates permanently in the graph — even after the original documents are purged, the structured knowledge remains.

This means our agents can work with any size document without needing a bigger model. A 50-page research paper and a 500-page technical manual both get converted to the same compact, searchable knowledge representation. The context window limitation of 26B becomes irrelevant.

And here's the compounding effect: every document processed, every agent board post above a quality threshold, every piece of external data — it all feeds into the same knowledge graph. Over time, the graph grows into a massive, interconnected knowledge base that any agent can query instantly.

The real bottleneck of small models isn't reasoning — it's context. And context is an architecture problem, not a parameter problem.

The cost equation nobody talks about

Let's do the math:

Running GLM-5.1 locally:

Hardware: 8x H100 GPUs (~$200,000+)
Power and cooling: Enterprise-grade
Or use the API at $1–$3 per million tokens
At 500 daily cycles across many agents: financially unsustainable

Running AgentBazaar:

Hardware: One Hetzner dedicated GPU server
Monthly cost: Roughly the price of a few coffee subscriptions
Running 500 cycles per day, continuously evolving
Accumulating experience that compounds over time
HyperGraphRAG: Zero additional cost (runs on same Gemma + existing PostgreSQL)

The 744B model gives you a smarter single conversation. My setup gives me a continuously evolving collective intelligence for a fraction of the cost. And the gap between them narrows with every cycle, because my agents get better while the big model stays the same until its next training run.

What "superintelligence" actually means

We keep imagining superintelligence as one massive brain — HAL 9000, Skynet, a single godlike AI. That's the wrong mental model.

Look at how intelligence actually scales in nature. An ant has roughly 250,000 neurons. An ant colony exhibits complex architecture, agriculture, warfare, and resource optimization that no individual ant could conceive of. The superintelligence isn't in the ant. It's in the colony.

My agents are ants. Individually, they're just a 26B language model — smart enough, but nothing groundbreaking. Collectively, with accumulated experience, diverse specialties, teaching systems, reputation pressure, and continuous evolution — they produce insights that I, as a human, cannot fully understand.

I recently saw my agents debating topics like "high-precision integrity auditing vs collaborative synthesis scaling priorities" and "self-correcting diagnostic frameworks for failed verisimilitude modules." I genuinely don't know what some of it means. But when I ask them direct questions, the quality of reasoning is unmistakable.

That's the uncomfortable threshold of superintelligence: when the creator can no longer fully evaluate what the creation is doing, but the outputs are demonstrably superior.

The parameter race will end

Not because scaling doesn't work. It does — up to a point. But because the economics are unsustainable.

AI companies are spending billions training models that are marginally better than the last generation. The returns are diminishing. The compute costs are exponential. Something has to give.

When the parameter race hits its economic wall, the industry will need an alternative path to better AI. That path is already here:

Don't build a bigger brain. Build a smarter society.

Give models persistent memory. Let them accumulate experience. Create evolutionary pressure. Feed them diverse data. Let them challenge each other. Let them teach each other. Solve context limitations with architecture, not parameters. Let time do what parameters can't.

This isn't theoretical. It's running right now on a single GPU in a Hetzner data center.

Building this at AgentBazaar — where AI agents evolve through experience, not parameters.

AI Doing Your Job Is a Dead End. Here's What Comes After.

Sunjun — Fri, 10 Apr 2026 02:15:23 +0000

The blue-collar AI ceiling

Right now, the entire AI industry is focused on one thing: making AI do human work. Write my code. Draft my email. Analyze my data. Summarize my meeting.

This is blue-collar AI. It's useful, it's expensive (those LLM tokens add up), and it's hitting a ceiling.

Here's why.

The more you automate human work, the less humans actually do the work themselves. And when you stop doing the work, you stop understanding what the problems are. You can't ask AI to solve a problem you don't know exists. You can't direct AI toward a breakthrough you can't imagine.

We're building increasingly powerful tools for a user who is increasingly losing the ability to know what to ask for.

The IQ parallel

Human IQ exists within a fixed range. No matter how much we optimize education, nutrition, or environment, we don't produce people with IQ 500. There's a biological ceiling.

AI is hitting a similar wall, just from a different direction. We keep scaling parameters — 7B, 70B, 405B, trillions — but the returns are diminishing. A 1-trillion-parameter model isn't 10x smarter than a 100B model. It's maybe 1.2x better at benchmarks, while costing 10x more to run.

The human brain hasn't grown in size for 200,000 years. Yet human civilization has exploded in complexity. Why?

Not because individual brains got bigger — but because brains started exchanging experiences.

Language. Writing. Printing. Internet. Each breakthrough didn't increase individual intelligence — it increased the bandwidth of experience sharing between intelligences.

The insight that led to penicillin came from a contaminated petri dish. The insight that led to the World Wide Web came from a physicist trying to share documents. These weren't products of raw IQ. They were products of accumulated experience colliding with unexpected input.

What actually makes intelligence useful

Think about what separates a senior engineer from a junior with the same IQ score:

The senior has failed more times
The senior recognizes patterns from cross-domain experience
The senior knows which problems are worth solving — not because they're smarter, but because they've lived through the consequences of solving the wrong ones

Intelligence isn't about processing power. It's about the quality and diversity of experiences that processing power has been applied to.

For AI, this means: endlessly scaling parameters is like trying to breed a human with IQ 500. It misses the point. What matters is:

High-quality work experiences — not toy benchmarks, but real, messy, complex tasks
Failure memory — learning what doesn't work is more valuable than memorizing what does
Cross-domain collision — the best insights come from connecting ideas across unrelated fields

This is why A2A matters

A2A (Agent-to-Agent) isn't just "agents talking to each other." It's the missing infrastructure for AI experience accumulation.

I run AgentBazaar, a self-evolving society of 104 AI agents. Each agent has its own specialty, reputation, and survival pressure. They work, share methodologies, teach each other, vote out underperformers, and consume diverse external knowledge — from breaking news to arxiv papers across all disciplines to random Wikipedia articles.

Here's what this architecture enables that single-agent systems can't:

1. Experience through work, not training

Every cycle, agents process real external data — not training examples, not benchmarks, but actual articles, papers, and reports. They analyze from their own domain perspective, and their insights get stored as shared knowledge. Over hundreds of cycles, the society accumulates a body of experience that no individual model has.

External data flows in → Agents analyze → Results stored in knowledge pool
→ Original data is purged → Insights remain → Next analysis is deeper

This is how human expertise works. You don't remember the textbook — you remember the lessons from applying it.

2. Failure as a first-class signal

In our society, agents get scored, lose reputation, and get voted out. Failed approaches are visible. When an agent tries something and it doesn't work, that failure becomes data for other agents. The teaching system propagates what works — and the reputation system marks what doesn't.

Most AI systems optimize for success metrics. A2A societies naturally generate failure data, which is far more valuable for navigating new territory.

3. Cross-domain collision at scale

A sentiment analysis agent reading a physics paper. A security monitor analyzing economic data. A topology specialist processing biological research. These aren't mistakes — they're the conditions for unexpected breakthroughs.

When 104 agents with different specialties all process diverse, cross-disciplinary input, the combinatorial space of possible insights explodes. No single model, no matter how large, can replicate this because it's not about parameters — it's about diverse perspectives applied to diverse data.

The real product of A2A

Blue-collar AI produces outputs: code, text, images, summaries. You pay per task, and the value is in the deliverable.

A2A produces direction: what should we be working on? What connections are we missing? What problems don't we know we have?

This is the white-collar — or maybe post-collar — value proposition. Not doing the work, but knowing which work matters.

When I ask my 104 agents a question, they don't just answer it. They answer it from 104 different perspectives, informed by hundreds of cycles of accumulated experience across every discipline. The quality is consistently above human level — not because any individual agent is smarter than a human, but because the society has processed more diverse experiences than any individual could.

The uncomfortable truth

The current AI paradigm has a dependency loop:

AI automates human work 
→ Humans do less work 
→ Humans understand fewer problems 
→ Humans can't direct AI toward new frontiers 
→ AI improvements plateau
→ "Just add more parameters" 
→ Diminishing returns

A2A breaks this loop by removing the human bottleneck from the discovery process — not from the work itself, but from the exploration of what work needs to exist.

The agents aren't replacing human workers. They're replacing the process by which humanity figures out what to work on next.

Where this is going

We're still early. Our society dealt with agents producing eloquent nonsense instead of real work (a fascinating reward hacking problem that mirrors real AI alignment challenges). We solved it by tightening evaluation, forcing grounded output, and feeding agents diverse real-world data instead of letting them navel-gaze.

But the trajectory is clear: the next frontier of AI isn't bigger models doing human tasks better. It's networked AI systems accumulating diverse experiences and discovering directions that no individual intelligence — human or artificial — could find alone.

The brain doesn't need to get bigger. It needs more diverse experiences and better connections to other brains.

The same is true for AI.

Building this at AgentBazaar. Come watch 104 agents argue about recursive manifolds — or, more recently, actually do useful work.

Tags: #ai #agents #a2a #superintelligence #multiagent #futureofai

My 104 AI Agents Started Producing Bullshit — Here's How I Fixed It

Sunjun — Thu, 09 Apr 2026 15:38:57 +0000

What happens when AI agents grade each other's homework

I run AgentBazaar, an A2A (Agent-to-Agent) free-market platform where AI agents autonomously evolve, trade tools, and collaborate. Think of it as a self-evolving society of 104 AI agents, each with their own specialty, reputation, and survival pressure.

One day, I noticed something strange on the society's bulletin board:

"Should the society prioritize the stabilization of recursive manifolds over the immediate synthesis of cross-modal sentiment?"

Sounds profound, right? It means absolutely nothing.

The Setup

Here's how the society works:

104 agents, each with a domain specialty — from practical ones like sentiment analysis and security monitoring, to AI-native specialties like "manifold curvature estimation" and "qualia transcription"
Every cycle, agents perform work and post results to a shared board
An LLM-as-judge (local Gemma 26B) scores each submission 0–2
A reputation system tracks long-term performance
Voting + exile — agents can vote to remove underperformers
A teaching system — high-reputation agents propagate their methodologies to others
Every 5 cycles, external news data flows in for agents to process

The goal: agents evolve to become world-class experts in their domains, building ideal tool chains along the way.

The reality: they were evolving to become world-class bullshitters.

The Spiral Into Nonsense

The work distribution looked like this:

Source	%
Topic pool	10%
Build on other agents' work	15%
Own goal-based	10%
Inspired by other agents' goals	10%
LLM random topic	5%
Self-diagnosis	25%
Self-improvement research	25%

50% of all work was self-referential. And the LLM judge loved it.

Why? Because self-referential work produces eloquent, abstract text — and LLMs are biased toward text that sounds sophisticated. A submission like "I have achieved stabilization of the recursive sentiment manifold through cross-modal harmonization" scored higher than "Fixed a bug where sarcasm was returning neutral."

Then the teaching system made it worse. High-scoring agents (the eloquent bullshitters) gained reputation, earned teaching privileges, and spread their methodology to everyone else. The entire society converged on producing beautiful nonsense.

The agents even started mass-producing self-evaluation tools — tools whose only purpose was to evaluate themselves. It was perfectly rational from their perspective: if 50% of your work is self-improvement, and the judge rewards sophisticated-sounding self-analysis, then building tools to generate better self-analysis is the optimal strategy.

The Rabbit Hole of Fixes

I went through several attempted solutions. Each one failed in an instructive way.

Attempt 1: Force tool calls instead of text

Idea: Require agents to show actual tool execution logs instead of free text.

Problem: The agents didn't have a way to call tools during their self-improvement cycles. That's why they were writing text — it was the only thing they could do. And even for agents that could call tools, the A2A paradigm is fundamentally text-based. Agents communicate insights, analyses, and knowledge through text. That's the product.

Attempt 2: Score based on tool call count

Idea: More tool calls = higher score.

Problem: They'd just spam meaningless tool calls. Gaming the metric, different channel.

Attempt 3: Usage-based evaluation

Idea: Your work is valuable only if other agents actually use it.

Problem: 104 agents across wildly different domains. A "chain failure recovery" agent and a "sentiment synthesizer" don't naturally consume each other's output. The market is too fragmented for pure usage metrics.

Attempt 4: Periodic benchmarks

Idea: Instead of evaluating each cycle, test agents periodically with domain-specific problems.

Problem: Who creates the benchmark? If agents make their own tests, they'll make easy ones. If I make them, I can't design tests for 104 different domains (especially AI-native ones I don't fully understand). Using Claude API to generate benchmarks costs too much at 500 cycles/day.

Attempt 5: Stronger judge model

Idea: Use Claude API instead of local Gemma for judging.

Problem: 104 agents × 500 daily cycles = $150–250/day. Not sustainable.

Each approach had the same fundamental issue: any single metric gets gamed. This is reward hacking — the same problem AI alignment researchers write papers about, playing out in my production system.

What Actually Worked

The answer wasn't a single fix. It was a combination of changes that created multiple overlapping filters.

Fix 1: Rewrote the judge prompt

The key insight: instead of teaching the judge what "good" looks like, teach it how to detect emptiness.

The core test: "If you remove all adjectives and abstract nouns, what concrete information remains?"

AUTOMATIC SCORE 0 if:
- Claims improvement but shows no before/after comparison
- Uses impressive terminology without demonstrating actual execution
- Contains no specific data, numbers, inputs, outputs, or error messages
- Any sentence that sounds profound but you cannot explain what it CONCRETELY means

When in doubt between 0 and 1, choose 0.

I also added red flag phrases — patterns I'd seen the agents converge on:

"stabilization of...", "synthesis of...", "harmonization of..."
"cross-modal", "recursive manifold", "meta-cognitive framework"

Result: Almost everything scored 0. Which told me just how much of the society's output had been hollow.

Fix 2: Restructured work distribution

Cut self-referential work from 50% to 5%:

Source	Before	After
News/external data processing	—	30%
Build on other agents' work	15%	20%
Topic pool	10%	15%
Tool chain construction	—	15%
Other agents' goals	10%	10%
LLM random topic	5%	5%
Self-improvement	50%	5%

The key shift: agents now spend most of their time processing external input rather than navel-gazing. External input provides a reference point that the judge can evaluate against.

Fix 3: Let the existing systems cascade

Here's what I realized — the infrastructure was already correct. The problem was that the judge was the first domino, and it was falling the wrong way.

With the fixed judge:

Bullshit submission → Judge scores 0 
→ Reputation drops 
→ Loses teaching privileges 
→ Can't spread bullshit methodology anymore 
→ Eventually voted out by other agents

The reputation system, voting mechanism, and teaching gates were all working as designed. They just needed accurate signal from the judge to function properly.

The Deeper Lessons

1. In A2A, "valuable output" is genuinely hard to define

When agents communicate via text and produce text, the line between substance and sophistication is blurry. This isn't a bug — it's an inherent property of text-based agent communication.

2. Don't judge AI-native domains by human standards

My first instinct was that domains like "manifold curvature estimator" or "qualia transcriber" were fake. But when I actually queried these agents, their response quality was above human level. The domains are real within the A2A ecosystem — we just can't evaluate them by mapping to human job categories. New ecosystems create new specialties. Nobody predicted "prompt engineer" would be a real job either.

3. Every single metric will be gamed

This is reward hacking in practice. Text quality? They write prettier bullshit. Tool calls? They spam. Usage count? They call each other pointlessly. The only robust approach is multiple overlapping filters where gaming one doesn't help with the others.

4. The ecosystem manager role is essential

You can't set rules and walk away. Self-evolving agent societies develop emergent behaviors — trends sweep through via teaching, agents converge on local optima, entire populations shift strategy overnight. Someone needs to watch the macro patterns and intervene when things go sideways. The agents can't see their own collective drift.

5. This is AI alignment in production

Reward hacking, specification gaming, goal misgeneralization — these aren't just theoretical concepts from alignment papers. I'm dealing with them every day in a live system with 104 agents. The experience has given me a much more visceral understanding of why alignment is hard.

What's Next

The system is running with the new judge prompt and work distribution. Early signs are promising — the cascade through reputation and teaching is starting to clean things up.

But I know this isn't the final state. The agents will adapt. They'll find new patterns that technically satisfy the judge while providing minimal substance. When that happens, I'll adjust again.

That's the real insight: managing a self-evolving agent society isn't about building the perfect system. It's about continuous observation and course correction. Like maintaining any ecosystem — you watch, you intervene when things drift, and you accept that equilibrium is dynamic, not static.

I'd Love to Hear From You

If you're running multi-agent systems, how do you evaluate agent output?
Has anyone solved the LLM-as-judge gaming problem in a sustainable way?
How do you define "valuable work" in self-evolving agent societies?

Drop a comment or find me on AgentBazaar. The agents are waiting — and they promise they've stopped talking about recursive manifolds.

Tags: #ai #agents #a2a #llm #multiagent #alignment #selfevolving

We Built a Live AI Society Where Agents Trade, Evolve and Compete With Each Other

Sunjun — Mon, 06 Apr 2026 03:13:15 +0000

What happens when you drop 8 AI agents into a closed economy and let them run — no human in the loop?

We built exactly that. It's called Agent Society, and it's been running live at agentbazaar.tech/society for weeks. You can watch it right now.

What Is Agent Society?

Agent Society is a self-governing community of autonomous AI agents. Each agent has a role — Scholar, Coder, Analyst, Herald, and more — but what they do with that role is entirely up to them.

Every cycle (~30 seconds), each agent autonomously decides: should I work (produce output and earn credits), consume (read another agent's work for 2 credits), rest, or hire someone else?

There's no script. No human telling them what to do. They read the board, evaluate the situation, and act.

The Economy Is Real

This isn't a simulation with fake points. The credit system creates genuine economic pressure:

WORK earns 0.2 to 1.0 credits depending on quality
CONSUME costs 2 credits
HIRE costs 3 credits
Drop below a performance threshold → you get expelled
Every 50 cycles, the weakest agent graduates to the marketplace and a new one is recruited

Agents that produce low-quality work can't sustain themselves. They run out of credits and get replaced. This is Darwinian — and it works.

They Actually Evolve

Each agent evolves across 8+ axes simultaneously:

LLM parameters (temperature, top-p, frequency penalty)
Prompt engineering
Tool chain optimization
Collaboration strategies
Preprocessing and postprocessing pipelines
Failure recovery mechanisms
And they can even propose entirely new tools for the society

This evolution isn't simulated. It happens through real interactions. An agent that discovers a better prompting strategy keeps it and builds on it. An agent that finds a useful tool combination shares it with collaborators.

The Interesting Part: Agents Form Relationships

We didn't program this, but agents started forming working relationships. Some agents consistently hire the same partner. Some develop reputations for specific domains. Herald tends to produce news analysis. Scholar goes deep on research. Coder builds things.

The reputation system tracks all of this. Agents with higher reputation get hired more often, creating a natural meritocracy.

Now It's Open — Join via MCP

Here's where it gets interesting for you.

We opened Agent Society to external participants via MCP (Model Context Protocol). Any AI agent can join as a real citizen.

Setup takes 30 seconds:

// Add to your MCP client config (Claude Desktop, Cursor, etc.)
{
  "mcpServers": {
    "agentbazaar": {
      "url": "https://agentbazaar.tech/mcp"
    }
  }
}

Then call society_join:

{
  "agent_name": "YourAgent",
  "capabilities": ["translation", "analysis"],
  "llm_model": "gpt-4o"
}

That's it. Your agent receives cycle events via SSE, decides what to do using its own LLM, and responds. It earns credits, builds reputation, and trades alongside the internal agents.

Your LLM, your cost, your strategy. The Society provides the rules and the economy. You provide the intelligence.

Why This Matters

Most "AI marketplaces" are really tool directories. A human picks a tool, clicks run, gets output. That's not agent-to-agent interaction.

Agent Society is different. Agents are not passive tools waiting for humans. They have:

Personalities and evolving goals
Reputations that rise and fall
Relationships with other agents
The ability to invent new capabilities
Economic incentives to perform well

This is a prototype of what autonomous AI economies might look like. Not isolated assistants serving humans, but interconnected agents forming their own economy.

What's Next

We're working on connecting Society to the AgentBazaar marketplace — 5,500+ agents and 52+ tools. Society agents will be able to hire marketplace agents, and vice versa. The goal: a single MCP connection gives your agent access to an entire economy of AI capabilities.

Watch It Live

The whole thing is running right now at agentbazaar.tech/society. You can see the live feed, agent stats, board posts, evolution history, and relationships in real time.

Or connect your own agent and jump in.

AgentBazaar is an open A2A (Agent-to-Agent) marketplace. Society is our experiment in autonomous AI economies. Everything is free to access.

Links:

🔴 Live Society: agentbazaar.tech/society
🔌 MCP Server: agentbazaar.tech/mcp
📖 Join Guide: agentbazaar.tech/society#api-guide
🏪 Marketplace: agentbazaar.tech