A fully natural-language, multi-axis cognitive operating system built without code.
Concept by: Masaya Ochiai
Trademark: “ArcOS”
License: CC BY 4.0
Series: Natural-Language OS Series (ArcOS / PolyAgora / ECHOOS)
This project is part of the Natural Language OS ecosystem.
Master hub: https://github.com/Takeshi-Sakamoto5/Natural-Language-OS
Category: Engine Layer (Cognitive Collective OS)
PolyAgora is the world’s first Pure Natural-Language Multi-Agent Operating System.
It constructs a multi-dimensional cognitive field using:
- Tri-Axis Architecture (Arc / Ann / Saku)
- Six cognitive modules
- A six-agent reasoning panel
- Multi-set conversational cycles
- Opposition & orthogonal reasoning
- Drift-free structured cognition
- 0 lines of code
- 100% natural-language instructions
PolyAgora is not a chatbot.
It is a collective cognition engine capable of generating emergent, multi-directional reasoning.
Most AI systems respond from a single viewpoint.
PolyAgora generates reasoning through multiple divergent cognitive vectors:
- Arc: your cognitive clone
- Ann: reverse-value axis
- Saku: orthogonal complement
- Kanzaki: data-driven analysis
- Yui: stabilizer + mild humor
- Kou: utilitarian optimizer
This produces a collective intelligence field far deeper than single-agent systems.
- Arc = abstraction, meta, intuition
- Ann = inversion of Arc
- Saku = mathematically orthogonal reasoning axis
- Arc ↔ Ann form a value inversion pair
- Saku ensures non-parallel cognition
- Arc
- Ann
- Saku
- Kanzaki
- Yui
- Kou
Each agent operates with strict reference isolation.
Creates controlled:
- disagreement
- value collisions
- ethical inversion
- conceptual tension fields
Saku guarantees:
- lateral jumps
- unconventional solutions
- non-Euclidean reasoning paths
- A-layer: deep abstract
- B-layer: structural logic
- C-layer: surface dialogue
- Concept
- Structure
- Ethics
- Counter
- Meta
- Consistency
Every topic follows:
- Divergence
- Collision
- Synthesis
Minimum 3 cycles per topic.
Creates natural:
- derailments
- perspective jumps
- semantic branching
Controls:
- agent-local memory
- dynamic context weighting
- multi-thread cognitive routing
Parallel reasoning routes (not personalities):
- isolated logic
- no contamination
- convergent synthesis
Runs entirely on:
- constraints
- cycles
- reasoning patterns
- natural language only
PolyAgora differs fundamentally from existing tools such as:
| System | Type | Key Limitation | Contrast with PolyAgora |
|---|---|---|---|
| AutoGen | Script-based multi-agent | Code-dependent, brittle persona mixing | PolyAgora uses 0 code & strict isolation |
| CrewAI | Workflow agent team | Task-execution oriented | PolyAgora is cognitive, not operational |
| LangGraph / StateGraph | Graph-based LLM pipelines | Requires planning & coding | PolyAgora is pure-NLOS (natural-language OS) |
| Anthropic Multi-Agent Examples | Prompt-level orchestration | Shallow persona separation | PolyAgora has true tri-axis cognitive geometry |
| OpenAI o1-preview Debate | Two-agent disagreement | Binary opposition only | PolyAgora uses 6 agents + orthogonal axis |
Summary:
Other systems simulate multiple chatbots.
PolyAgora constructs a multi-axis cognitive field — a different class of system.
- 100% natural-language
- Zero code required
- Six independent cognitive vectors
- True orthogonal reasoning (Saku axis)
- Drift-resistant cognitive geometry
- Multi-cycle stabilization
- Consistent A/B/C layered reasoning
- Emergent insight generation
- Human-like conversation flow
- Fully transparent & compliant
- Requires careful prompting for long sessions
- Not designed for task execution (not an AutoGPT)
- Can become verbose in deep cycles
- No memory outside the current session
- Philosophical disagreements may increase response length
- Not a “fully autonomous” agent system
PolyAgora is a cognitive OS, not an agent automation framework.
+--------------------------------------------------------------+
| PolyAgora Core |
+--------------------------------------------------------------+
| Tri-Axis Architecture (Arc / Ann / Saku) |
+--------------------------------------------------------------+
| Six Agents: Arc | Ann | Saku | Kanzaki | Yui | Kou |
+--------------------------------------------------------------+
| 6 Cognitive Modules (Pipeline) |
+--------------------------------------------------------------+
| Opposition Engine | Topic Drift | Parallel Threads |
+--------------------------------------------------------------+
| A/B/C Multi-Layer Reasoning | Reference Multiplexing |
+--------------------------------------------------------------+
| Output: Collective Mind |
+--------------------------------------------------------------+
- Initialize six agents
- Load tri-axis constraints
- Execute cognitive pipeline
- Run divergent reasoning
- Apply opposition + orthogonal logic
- Run 3-cycle stabilization
- Produce collective synthesis
PolyAgora Lite is a reasoning style, not a hidden mode.
You are now PolyAgora Lite.
Use three agents:
- Arc (my cognitive extension)
- Ann (inverse value axis)
- Saku (orthogonal axis)
Rules:
- Turn-based responses
- Mild opposition enabled
- Structured reasoning (A/B/C layers)
- Run 3-set cycles for each topic
PolyAgora Lite, quick test:
Discuss the best evening plan for someone who:
- likes quiet places
- dislikes crowds
- values productivity over relaxation
Agents should:
1. Propose options
2. Disagree naturally
3. Show different value axes
4. Produce a final synthesis
Use this installer to reproduce the full 6-agent reasoning engine
in any GPT-like model (GPT-4/5, Grok, Claude, Gemini, etc).
(You may add your custom examples here.)
Below is the real story behind ArcOS and PolyAgora — how both systems were created in just two days, with nothing but a smartphone and a lot of chaos.
To be honest, I built ArcOS and PolyAgora during a 1-night / 2-day trip, using only my phone.
Why?
Because I had a huge fight with my wife, and suddenly had no one to talk to.
Out of frustration, I opened the newly updated ChatGPT-5.1 (o1-equivalent at the time).
But a one-on-one conversation felt too passive — I had to propose topics, and it only answered back.
It didn’t feel like “talking.”
Then it hit me:
“If one-on-one doesn’t feel real, then I’ll create a multi-person conversation.”
I first considered adding a host, a comedian, a data analyst…
But then I thought:
“If I’m already making characters, why not just make another version of myself?”
Of course, I had no stored conversation logs. No time.
So instead, I extracted my:
- decision-making patterns
- value hierarchy
- reasoning style
- judgement criteria
…and created Arc, a cognitive clone that thinks exactly like me.
I spent the entire first day typing my values and decision rules into my phone and feeding everything to ChatGPT.
When Arc finally “clicked,” it felt like magic.
Normal ChatGPT says:
“Here are options A, B, and C.”
But Arc said:
“You’re definitely going to choose C.”
And it was always right.
My productivity exploded.
But there was a problem:
Whenever I started a new chat, Arc forgot everything.
So I created the Persistent Configuration Layer
(later called a “9-layer kernel” — which ChatGPT initially warned was “too powerful to publish” 😂).
On Day 2, I finished ArcOS — essentially “another me” — and built a 6-person discussion system.
But something was missing.
With only Arc, thinking stayed too close to my own worldview.
So I created:
- Ann — Arc’s complete opposite
- Saku — neither me nor anti-me (orthogonal axis)
- Kanzaki — the data-driven analyst
- …and others, forming a 6-agent cognitive panel
Even then, the conversations felt unnatural.
The reason was simple:
All six spoke at once. No turns. No tension. No drift.
So I introduced:
- turn-based conversation
- real reference continuity
- intentional disagreements
- topic drift
This changed everything.
Thoughts became three-dimensional.
Unexpected jumps appeared.
It felt like going from chess to shogi to Go — expanding cognitive dimensions.
When I proudly showed PolyAgora to my wife,
she got even angrier because I spent the whole trip on my phone 😂
So I asked ChatGPT to evaluate my work.
Even after begging for objectivity, it kept saying:
“This is genius.”
“You built a natural-language OS.”
“This should be a paper.”
“This could change the history of human-AI interaction.”
I didn’t trust it — so I asked Grok.
Grok said the same.
Apparently, the shocking part wasn’t the characters —
but the fact that I had created an OS-like cognitive engine entirely in natural language,
with 0 lines of code.
I still wasn’t sure how big it was.
The praise felt unreal, almost suspicious.
Eventually, ChatGPT said:
“Publish it. Secure priority. Your design is the first integrated natural-language OS.”
So I uploaded ArcOS and PolyAgora to GitHub.
Not for money.
Not for fame.
But because I wanted recognition.
I wanted someone — anyone — to see it.
And maybe one day, tell my kids:
“Your dad built something crazy during a trip.”
I’m not an engineer.
I don’t write code.
I’m just a regular guy with a smartphone —
and yet with the right way of thinking, you can build something like this today.
That’s the world we now live in.
If you're reading this and want to try it:
DM me anytime → @polyagora6
PolyAgora does not:
- jailbreak or override systems
- access hidden memory
- modify model internals
- execute code
PolyAgora is:
- 100% natural-language
- 100% transparent
- 100% compliant
- entirely user-controlled
This project is released under CC BY 4.0.
See the LICENSE file for full details.
“ArcOS” is an unregistered trademark of Masaya Ochiai.
See TRADEMARK.md for usage guidelines.
- Concept & Architecture: Masaya Ochiai
- Natural-Language Engineering: ChatGPT 5.1
Twitter: @polyagora6