Runtime Society: A Society Where AI Agents Work Together

🎥 The YouTube version is also available:

Runtime OS: The Missing Infrastructure for Autonomous AI | Beyond AI Agents

Books : Runtime Society: The Social Operating System for the AI Era

Introduction

Generative AI has so far been used primarily as a tool that answers human questions.

It writes text.

It summarizes documents.

It writes code.

It responds to inquiries.

However, as AI agents become widespread, this structure will change significantly.

AI will not merely receive instructions from people one by one. It will increasingly be able to:

• Understand goals
• Gather the information it needs
• Delegate work to other AI agents
• Evaluate results
• Decide what to do next

Furthermore, multiple AI agents will take on different roles and work together to carry out business operations.

For example:

• A Sales Agent understands customer requirements
• A Contract Agent checks contractual conditions
• An Inventory Agent assesses supply availability
• A Pricing Agent prepares a quotation
• A Risk Agent detects potential issues
• An Approval Agent asks a human for confirmation

In this situation, AI is not operating alone.

Multiple AI agents are dividing responsibilities and working together like members of a society.

We call this kind of system—where people, AI, and organizations coordinate at runtime—a Runtime Society.

A Runtime Society is not simply a society in which AI exists.

It is a society in which AI has roles, makes judgments, coordinates with others, and works while respecting boundaries of responsibility.

A Single AI Is Not Enough

When we try to entrust everything to one AI, many problems emerge.

It is not easy for a single AI to understand, judge, and execute sales, contracts, quality, legal matters, and every other function at once.

Different types of work require different knowledge.

Different rules apply.

Different permissions are required.

For example, a Sales Agent prioritizes customer relationships.

A Pricing Agent prioritizes profit margins.

An Inventory Agent prioritizes supply availability.

A Legal Agent prioritizes contractual and compliance risks.

Each judgment may be valid in its own context, yet the overall decisions may still conflict.

The Sales Agent may want to offer a discount.

The Pricing Agent may want to protect the margin.

The Inventory Agent may want to extend the delivery date.

The Customer Support Agent may want to respond immediately.

In such situations, simply increasing the number of AI agents will not solve the problem.

What is needed is a mechanism that defines:

• Who is responsible for what
• Which AI has final decision authority
• How disagreements are handled
• When the process returns to a human
• Who is accountable

Runtime Society is a way of thinking for designing this coordination structure.

What Is a Runtime Society?

A Runtime Society is an environment in which multiple AI agents, people, and organizations coordinate at runtime while holding defined roles.

The important point here is the phrase “at runtime.”

It is not limited to a fixed workflow defined in advance.

Depending on the actual situation, the system dynamically determines:

• Who should respond
• Which knowledge should be used
• Which AI agent should be asked to help
• Which rules should apply
• When human judgment should be requested

A Runtime Society requires several core elements:

• Agent: the actor that takes action
• Role: the responsibility assigned to that actor
• Goal: the objective to be achieved
• Context: the current situation
• Policy: the rules that must be followed
• Boundary: the limits that must not be crossed
• Coordination: the mechanism for working together
• Negotiation: the process for reconciling different views
• Escalation: transfer to a human or higher-level authority
• Decision Trace: the record of decisions
• Human Gate: the point at which people intervene

By combining these elements, multiple AI agents can work together safely.

AI Also Needs Roles

In human organizations, roles are clear.

Sales.

Development.

Legal.

Quality.

Finance.

Management.

Each function has different responsibilities and authorities.

AI needs the same kind of structure.

For example, imagine the following AI agents in a company:

• Sales Agent
• Contract Agent
• Risk Agent
• Inventory Agent
• Pricing Agent
• Customer Support Agent

The Sales Agent understands the relationship with the customer.

The Contract Agent checks contractual conditions.

The Risk Agent evaluates legal and credit risks.

The Inventory Agent checks inventory and delivery feasibility.

The Pricing Agent calculates prices and margins.

The Customer Support Agent communicates with customers.

By specializing, these agents can often make more accurate judgments than one enormous, general-purpose AI.

However, specialization also makes coordination necessary.

This is where Role design becomes important.

At a minimum, a Role should define:

• Purpose
• Assigned responsibilities
• Knowledge that may be used
• Data that may be accessed
• Actions that may be executed
• Scope of decision-making authority
• Escalation conditions
• Responsible entity

By defining not only AI capability but also roles and boundaries, AI can operate safely within an organization.

How Do AI Agents Coordinate?

A society of multiple AI agents needs mechanisms for coordination.

In simple cases, work can proceed in sequence.

For example:

A customer request is received.

The Sales Agent organizes the request.

The Contract Agent reviews the conditions.

The Pricing Agent prepares a quotation.

After approval, the Customer Support Agent responds to the customer.

This resembles a conventional workflow.

In real business operations, however, a sequential process is often insufficient.

Multiple AI agents may need to make different judgments at the same time and reconcile their results.

For example, imagine that a customer places a large order with a very short delivery deadline.

The Sales Agent wants to accept the order.

The Inventory Agent concludes that supply will be difficult.

The Pricing Agent wants to add an urgent-response fee.

The Customer Support Agent believes that a quick reply is necessary.

In this case, a Runtime Society needs a coordination process such as the following:

1. Each AI agent makes a judgment from its own perspective.
2. The agents share their evidence and constraints.
3. They confirm the common Goal.
4. They detect conflicting conditions.
5. They generate alternatives.
6. If no agreement can be reached, they escalate to a human.

Coordination among AI agents is not merely the exchange of messages.

It is the process of creating a meaningful overall decision while sharing Goals, Context, Policies, and Boundaries.

AI Agents Can Also Come into Conflict

If multiple AI agents have different objectives, conflict will naturally arise.

For example:

• Maximizing revenue
• Maintaining profit margins
• Improving customer satisfaction
• Optimizing inventory
• Ensuring legal compliance
• Minimizing risk

These objectives do not always point in the same direction.

Prioritizing customer satisfaction may reduce margins.

Reducing inventory may increase delivery risk.

Prioritizing revenue may increase legal or compliance risk.

The same kinds of conflicts occur between departments in human organizations.

They also occur in AI organizations.

For this reason, Conflict Resolution is an important part of Runtime Society.

Possible approaches include:

• Priority rules
• Shared KPIs
• Constraints defined by Policy
• Decisions based on risk levels
• Mediation by a higher-level Agent
• Voting
• Scoring
• Escalation to a human

The important point is to design the method in advance.

AI agents should not decide compromises on their own without guidance. Conflicts must be resolved according to the organization’s values and accountability structure.

Coordination Requires a Shared Goal

For AI agents to coordinate effectively, they need a shared Goal.

For example, if the only Goal is:

“Increase sales,”

the system may produce excessive discounts or overly aggressive proposals.

By contrast, a Goal such as:

“Achieve sustainable, profitable growth while maintaining long-term customer relationships”

makes more balanced decisions possible.

In a Runtime Society, each AI agent needs a local Goal, while the organization also defines a shared Global Goal.

For example:

Sales Agent
Create proposals that meet customer needs.

Pricing Agent
Balance profitability and market competitiveness.

Risk Agent
Prevent unacceptable risks.

Global Goal
Achieve sustainable transactions while maintaining trusted customer relationships.

This Global Goal helps direct the judgments of individual AI agents toward overall optimization.

Runtime Society and the Community Graph

In the previous article, I introduced the Community Graph, which represents relationships among people, AI, organizations, knowledge, and events.

Runtime Society operates on top of this Community Graph.

The Community Graph represents structures such as:

• Who is connected to whom
• Which AI belongs to which organization
• Which knowledge each actor may access
• Who is responsible for which decisions
• Which Agents should coordinate with one another

Runtime Society uses this structure to carry out actual work.

In other words:

The Community Graph represents the structure of society.

Runtime Society represents the movement of society.

It is not a static organizational chart. It is a model of a society that actually operates.

Runtime Society and Trust Infrastructure

For AI agents to coordinate, they need mechanisms that allow them to trust one another appropriately.

Is the information produced by a particular AI correct?

Does that AI have the authority to make the relevant judgment?

Is it using only authorized data?

Has the result been altered?

Can the process be traced if a problem occurs?

These questions are supported by Trust Infrastructure.

In a Runtime Society, it should be possible to confirm the following information for each Agent:

• Identity
• Role
• Authority
• Policy
• Boundary
• Knowledge Source
• Decision Trace
• Responsible Organization

For example, when a Pricing Agent generates a quotation, it should be possible to verify:

• Which price list it used
• Which discount Policy it applied
• Whether it had the authority to offer that discount
• Who gave final approval

Without Trust Infrastructure, a Runtime Society becomes a complex black box.

With Trust Infrastructure, coordination among AI agents can become explainable and governable.

Where Is a Human Gate Needed?

A Runtime Society does not need to complete every process using AI alone.

On the contrary, it is important to design where human intervention is required.

Examples include:

• High-value contracts
• Decisions that create legal liability
• Decisions affecting human rights or employment
• Major quality risks
• Cases in which AI agents disagree
• Unprecedented cases
• Conflicting Policies
• User objections or appeals

In such situations, the process should return to a human through a Human Gate.

The important point is not to treat people as mere final approvers.

AI should organize and present:

• What it considered
• Where opinions diverged
• What risks remain
• What options are available

A Human Gate is not a place where people must reconsider everything from zero.

It is a place where AI structures the decision and people make the final decision with responsibility.

Conversations Alone Are Not Enough

It may appear that multiple AI agents can coordinate simply by having natural-language conversations.

However, conversation alone is not enough.

Natural language is ambiguous.

Different agents may have different assumptions.

Important constraints may be overlooked.

For this reason, a Runtime Society needs structured information shared among AI agents.

For example:

• Goal
• Context
• Role
• Intent
• Constraint
• Policy
• Candidate
• Risk
• Decision
• Confidence
• Evidence
• Escalation Reason

AI coordination requires more than saying:

“I think this is the right approach.”

It needs a structure such as:

“For this Goal, based on this Evidence and Policy, while considering these Constraints, I propose this decision.”

This enables other AI agents and humans to verify the judgment.

Decision Trace Becomes the Memory of Society

In a Runtime Society, many decisions are made every day.

Which Agent proposed what?

Which AI objected?

Which Policy was applied?

Where did the process pass through a Human Gate?

What was the final outcome?

By retaining these records as a Decision Trace, the Runtime Society can learn.

When similar situations occur, it can refer to past decisions.

It can improve failed coordination patterns.

It can reduce unnecessary Escalations.

It can identify contradictions in Policy.

In other words, a Decision Trace is not merely the log of an individual AI agent.

It is the memory that accumulates the experience of society as a whole.

Just as human societies have accumulated institutions, legal precedents, and customs, a Runtime Society can mature through its decision history.

An Implementation Example of a Runtime Society

Consider designing an enterprise order-management process as a Runtime Society.

The participating Agents might include:

• Customer Agent
• Sales Agent
• Pricing Agent
• Inventory Agent
• Contract Agent
• Risk Agent
• Approval Agent
• Human Manager

The process might look like this:

Customer Request
↓
The Sales Agent organizes the requirements
↓
The Inventory Agent checks supply availability
↓
The Pricing Agent calculates the price
↓
The Contract Agent reviews the terms
↓
The Risk Agent evaluates risks
↓
A Coordination Agent integrates the judgments of all Agents
↓
Automatic execution if the action remains within the Boundary
↓
Human Gate if the action exceeds the Boundary
↓
The result is communicated to the customer
↓
The Decision Trace is stored

The important point is that this is not merely a business workflow.

Each Agent participates according to the situation, requests additional information when necessary, and delegates work to other Agents.

A Runtime Society is therefore not fixed automation. It is a dynamic organization whose composition changes according to the situation.

Runtime Society Can Also Be Applied to Local Communities

Runtime Society is not limited to internal enterprise operations.

It can also be applied to local communities.

Consider a day on which a large event takes place.

• An Event Agent predicts the number of visitors
• A Mobility Agent analyzes transportation congestion
• A Store Agent checks the status of nearby businesses
• A Weather Agent assesses weather-related risks
• A Tourism Agent recommends visitor routes
• A Safety Agent monitors dangers
• A Community Agent checks the impact on local residents

If these AI agents coordinate, they can provide:

• Transportation guidance that avoids congestion
• Customer traffic for nearby businesses
• Distribution of tourists across locations
• Safety information
• Consideration for local residents

This makes it possible to increase value across the entire community rather than optimizing only one company.

This is a Runtime Society that puts Community Intelligence into action.

Runtime Society and the Relationship Economy

In the Relationship Economy, ongoing relationships among people, AI, and organizations create value.

Runtime Society is the mechanism that turns those relationships into actual action.

Knowledge Flow delivers knowledge.

State Understanding interprets the current situation.

Community Graph represents relationships.

Trust Infrastructure defines safe boundaries.

Runtime Society coordinates multiple actors.

Decision Trace remembers the outcomes.

Together, they create the following cycle:

Knowledge
↓
Understanding
↓
Coordination
↓
Decision
↓
Action
↓
Trust
↓
Relationship
↓
Value

Runtime Society is an execution foundation for transforming AI from an automation tool into a member of society.

Risks of Runtime Society

Runtime Society offers significant potential.

At the same time, when multiple AI agents are connected, new risks emerge that do not exist with a single AI.

For example:

• AI agents may share incorrect assumptions
• One incorrect judgment may spread through the system
• Accountability may become unclear
• Agents may place excessive trust in one another’s judgments
• Unnecessary processes may be repeated
• Goals may gradually drift
• Conflicting interests may cause the system to stall
• Humans may lose the ability to understand the system as a whole

For this reason, implementation requires mechanisms such as:

• Clear Roles
• Least privilege
• Shared Goals
• Boundaries
• Timeouts
• Deadlock Detection
• Escalation
• Decision Trace
• Audit
• Human Override

Increasing the number of AI agents is not the same as increasing intelligence.

Without appropriate coordination design, complexity may increase without producing better outcomes.

Conclusion

As AI agents become widespread, AI will not merely support individual people. It will increasingly work in coordination with other AI agents.

Sales AI.

Contract AI.

Pricing AI.

Risk AI.

Regional AI.

Public-sector AI.

Each will have a role, make judgments, and act toward a shared Goal.

But simply connecting AI agents does not create a society.

Roles.

Responsibilities.

Authority.

Boundaries.

Trust.

Conflict resolution.

Human intervention.

Decision history.

Only when these are designed can multiple AI agents work together safely.

A Runtime Society is not a society in which AI acts freely without limits.

It is a society in which people, AI, and organizations understand one another’s roles and boundaries, coordinate responsibly, and create value together.

And this mechanism of coordination becomes the execution foundation that makes the Relationship Economy work in practice.