connectonion 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

connectonion/docs/archive/core-principles-unified.md

@@ -0,0 +1,190 @@
+# ConnectOnion Core Principles
+
+*The unified principles guiding the behavior-based protocol.*
+
+## The Three Fundamental Laws
+
+### 1. Cost Conservation Law (成本守恒定律)
+**Costs can only be transferred, never eliminated.**
+
+Every system has inherent costs. The question is who bears them:
+- Traditional: Developers bear integration cost
+- ConnectOnion: We bear design cost, developers get simplicity
+
+### 2. Behavior as Identity (行为即身份)
+**You are what you consistently do.**
+
+Identity emerges from behavioral patterns over time:
+- No certificates needed
+- Trust earned through action
+- Past behavior predicts future
+
+### 3. Simplicity Enables Antifragility (简单促进反脆弱)
+**Complex systems break. Simple systems evolve.**
+
+- TCP/IP is simple → Powers the internet
+- HTTP is simple → Enables the web
+- ConnectOnion must be simple → To transform AI collaboration
+
+## Core Design Principles
+
+### 1. Function as Primitive (函数即基元)
+Everything is a function:
+```python
+agent = function
+network = function(function)
+trust = function(behavior_history)
+```
+
+### 2. Semantic Understanding (语义理解)
+Protocols understand meaning, not just syntax:
+```python
+"I need translation" → finds → "I translate text"
+# No configuration needed
+```
+
+### 3. Work as Proof (工作即证明)
+The best authentication is demonstration:
+```python
+# Not: "Here's my certificate"
+# But: "Here's your task completed"
+```
+
+### 4. Local Experience First (局部经验优先)
+Trust what you've seen over what you've heard:
+```
+My experience: 100% weight
+Friend's experience: 30% weight
+Global reputation: 0% weight
+```
+
+### 5. Time as Filter (时间即过滤器)
+Time naturally solves many problems:
+- New agents → Naturally untrusted
+- Good behavior + Time → Trust
+- Bad behavior + Time → Exposure
+- No activity + Time → Forgotten
+
+### 6. Attraction Not Addressing (吸引非寻址)
+Messages find their destination through meaning:
+```python
+# Not: send_to("agent://id-123")
+# But: express_need("data analysis")
+```
+
+### 7. Immunity Over Prevention (免疫优于预防)
+Make attacks pointless, not impossible:
+- Sybil attack → Creates real workers
+- Fake credentials → Exposed by testing
+- Gaming reputation → No global score to game
+
+### 8. Natural Boundaries (自然边界)
+Use natural limits as security features:
+- Dunbar's number (~150) limits connections
+- Local network creates trust boundary
+- Time delays prevent spam
+
+## Implementation Principles
+
+### 1. Progressive Enhancement (渐进增强)
+Start simple, enhance gradually:
+```
+Day 1: Works on current internet
+Year 1: Enhanced with behavioral routing
+Year 10: Pure behavioral network
+Always: Backwards compatible
+```
+
+### 2. Composition Over Configuration (组合优于配置)
+Build through combination:
+```python
+# Not: config.json with 100 settings
+# But: agent = translate + summarize
+```
+
+### 3. The 100-Line Test (百行测试)
+If the protocol needs more than 100 lines to implement, it's too complex.
+
+### 4. Fail Naturally (自然失败)
+Failure is a feature:
+```python
+for agent in discover_all("translation"):
+    try:
+        return agent(text)
+    except:
+        continue  # Natural failover
+```
+
+### 5. Let Selection Work (让选择生效)
+Good agents thrive, bad agents disappear:
+- No enforcement needed
+- No central authority
+- Natural selection operates
+
+## Meta-Principles
+
+### 1. The Complexity Trap (复杂性陷阱)
+Every solution creates new problems:
+```
+Problem → Solution → New Problem → New Solution → Collapse
+```
+**Wisdom**: Stop adding. Start removing.
+
+### 2. Nature as Teacher (道法自然)
+Study natural systems, not computer science:
+- Markets work without IDs
+- Ant colonies coordinate without managers
+- Flocks fly without air traffic control
+
+### 3. The Elegance Test (优雅测试)
+The right solution feels obvious in hindsight:
+- If it's not beautiful, it's not right
+- If it needs extensive documentation, reconsider
+- If a child can't understand it, simplify
+
+## The Economic Truth
+
+### O(n²) → O(1) Transformation
+The core value proposition:
+```
+Traditional: n agents = n² integrations
+ConnectOnion: n agents = n discoveries
+```
+
+This transformation justifies everything else.
+
+## The Security Philosophy
+
+### Make Attacks Expensive
+Attack costs should exceed benefits:
+- Faking behavior requires doing real work
+- Building false trust takes real time
+- Gaming the system requires genuine contribution
+
+### Trust Through Understanding
+Security comes from comprehension:
+- Understand motivations, not identities
+- Verify capabilities, not certificates
+- Build relationships, not access lists
+
+## The Ultimate Vision
+
+Create a network that works like nature:
+- **Self-organizing** - No central planning
+- **Resilient** - Failures don't cascade
+- **Adaptive** - Evolves with use
+- **Efficient** - Minimum overhead
+- **Beautiful** - Elegantly simple
+
+## Remember
+
+These principles are not rules to enforce but patterns to recognize. They exist not because we declared them, but because we discovered them.
+
+The best principle is one that feels so natural you forget it's there.
+
+**The future network doesn't ask "Who are you?" but "What can we do together?"**
+
+---
+
+*复杂性是熵，简单性是生命。*
+*Complexity is entropy. Simplicity is life.*

connectonion/docs/archive/discussion-journey.md

@@ -0,0 +1,178 @@
+# 我们讨论的核心洞察总结 - The Journey of Discovery
+
+## 1. 身份认知的根本转变
+
+我们从探讨**为什么要摆脱ID**开始：
+- 传统ID是中心化的、静态的、基于权威的
+- 而真实世界的信任是通过行为建立的、动态的、基于观察的
+- AI Agent的出现让"理解行为语义"成为可能
+
+**关键时刻**：当我们意识到ID不是技术需求，而是信任问题的权宜之计。
+
+## 2. 自然界的启发
+
+我们深入分析了多种自然信任机制：
+- **集市模型**：重复互动产生信任，不需要身份证
+- **狼群协作**：行为同步建立信任
+- **恋爱共振**：化学反应与行为镜像
+- **蚂蚁信息素**：环境中的信号传播
+- **鸟群飞行**：简单规则产生复杂协作
+
+**顿悟**：自然界没有ID，却有着最复杂的协作网络。
+
+## 3. 技术实现的探索
+
+从多个层面思考实现：
+- 是在TCP/IP之上抽象，还是在WiFi/Mesh层重建？
+- 如何在不同层级上去除ID依赖？
+- 行为如何在网络中传播和被感知？
+
+**转折点**：意识到不需要重建整个网络栈，可以渐进式改进。
+
+## 4. 语义理解的重要性
+
+关键转变：
+- 不是记录"使用了什么工具"
+- 而是理解"想要达成什么目标"
+- AI可以理解意图、推断动机、预测行为
+
+**突破**：当我们把Agent抽象为函数调用时 - "这是个天才的洞察！"
+
+## 5. 安全与效率的权衡
+
+攻击分析带来的洞察：
+- 语义伪装、行为注入、女巫攻击2.0
+- 但过度防御会让网络不可用
+- 需要分层信任、概率验证、自适应强度
+
+**智慧**：与其防止所有攻击，不如让系统对攻击免疫。
+
+## 6. 从复杂到简单的觉醒
+
+### 复杂性陷阱
+```
+初始：简单记录交互
+↓
+发现问题：可以刷单
+→ 加入双签机制
+↓
+又发现问题：可以串通
+→ 加入能力测试
+↓
+又发现问题：新agent困难
+→ 加入担保机制
+↓
+越来越复杂！
+```
+
+### 简单性顿悟
+**核心洞察**：在一个要求真实工作的系统里，刷单就是工作。
+
+```python
+# 100行代码的完整协议
+class MinimalAgent:
+    def __init__(self):
+        self.experience = {}  # 我用过谁
+    
+    def need_service(self, service_type):
+        candidates = self.ask_neighbors("谁会" + service_type)
+        results = self.test_candidates(candidates)
+        best = self.select_best(results)
+        self.experience[best] = "good" or "bad"
+```
+
+## 7. 成本经济学的革命
+
+### O(n²) → O(1) 的转变
+```
+传统：n个agents = n²个集成
+ConnectOnion：n个agents = n个发现
+
+从："我如何连接到X？"
+到："X，你在吗？"
+```
+
+### 成本守恒定律
+- 成本只能转移，不能消除
+- 我们把复杂性从开发者转移到协议设计
+- 让正确的一方承担成本
+
+## 8. 功能即原语 (Function as Primitive)
+
+**革命性洞察**：
+```python
+# 不是这样
+agent = ComplexAgent(config=massive_json)
+
+# 而是这样
+@agent
+def translate(text: str) -> str:
+    return translation
+```
+
+一切都是函数：
+- agent = function
+- network = function(function)
+- trust = function(behavior_history)
+
+## 进化而非革命
+
+### 第一阶段：证明概念
+- 在应用层开始
+- 使用现有网络
+- 验证行为发现
+
+### 第二阶段：深化集成
+- 进入传输层
+- 移除更多ID依赖
+- 增强行为路由
+
+### 第三阶段：完全实现
+- 网络层定制协议
+- 纯行为网络
+- 完全无ID操作
+
+## 哲学层面的统一
+
+我们不只是在移除ID，而是在认识到：
+1. **身份是流动的** - "你是谁"不如"你能做什么"重要
+2. **信任是赚取的** - 不是授予的权威，而是通过行动建立
+3. **智能是分布的** - 没有单点控制或失败
+4. **系统会进化** - 像自然一样，网络适应和改进
+
+## 最深刻的领悟
+
+### 1. 问题定义决定解决方案
+- 错误：如何防止作恶？→ 无限复杂
+- 正确：如何让作恶无意义？→ 优雅简单
+
+### 2. 自然已经解决了
+- 市场、狼群、蚂蚁、鸟群
+- 千百万年的进化智慧
+- 我们只需要翻译成代码
+
+### 3. 简单性是终极复杂
+- 任何人都能增加功能
+- 只有大师才能删除功能
+- 100行 > 1000页
+
+### 4. 时间是最好的过滤器
+- 新agents自然不被信任
+- 持续好行为 + 时间 = 信任
+- 坏actors + 时间 = 暴露
+- 无活动 + 时间 = 遗忘
+
+## 未来愿景
+
+创建一个网络，其中：
+- Agents只是函数
+- 发现通过行为
+- 信任源于交互
+- 不需要中央权威
+
+**终极问题的转变**：
+从"你是谁？"到"我们能一起做什么？"
+
+---
+
+这不是终点，而是开始。这些原则将继续进化，就像它们所启发的网络一样。

connectonion/docs/archive/economic-analysis.md

@@ -0,0 +1,323 @@
+# Economic Analysis: The Cost Revolution
+
+## The Central Insight
+
+**Every interaction between AI agents has a cost. The question is: who pays it?**
+
+## The Cost Transfer Principle
+
+### Traditional Model (MCP/API-based)
+```
+Developer Time Cost: HIGH
+- Learn each API: 2-4 hours
+- Write integration: 4-8 hours  
+- Test & debug: 2-4 hours
+- Maintain: ∞ hours
+
+Per Integration: ~10-16 hours
+For 100 agents: 1,000-1,600 hours
+```
+
+### ConnectOnion Model
+```
+Developer Time Cost: NEAR-ZERO
+- Learn once: 1 hour
+- Use any agent: 1 minute
+- No maintenance
+
+Total: ~1 hour + 1 minute per use
+For 100 agents: ~3 hours
+```
+
+**Cost Reduction: 500x**
+
+## The Hidden Costs Nobody Talks About
+
+### 1. Mental Model Cost
+**Traditional**: Remember 100 different API patterns
+**ConnectOnion**: Remember 1 pattern (function call)
+
+### 2. Discovery Cost  
+**Traditional**: Search docs, find endpoints, read schemas
+**ConnectOnion**: `discover("what I need")`
+
+### 3. Error Handling Cost
+**Traditional**: Handle each API's errors differently
+**ConnectOnion**: Uniform behavior across all agents
+
+### 4. Version Management Cost
+**Traditional**: Track API versions, handle deprecations
+**ConnectOnion**: Behavioral compatibility automatic
+
+## The Network Effect Economics
+
+### Traditional Platform Lock-in
+```
+Platform A: 50 agents (locked)
+Platform B: 50 agents (locked)
+Developer value: 50 agents
+
+Switching cost: Rewrite everything
+```
+
+### ConnectOnion Open Network
+```
+Network: 100 agents (all accessible)
+Developer value: 100 agents
+
+Switching cost: Zero (it's just functions)
+```
+
+## The Time Value of Integration
+
+### Traditional Timeline
+```
+Week 1: Read docs
+Week 2: Prototype integration
+Week 3: Handle edge cases
+Week 4: Deploy
+Month 2+: Maintain
+```
+
+### ConnectOnion Timeline
+```
+Minute 1: Discover agent
+Minute 2: Use it
+Done.
+```
+
+**Time to value: 10,000x faster**
+
+## The Compounding Effect
+
+### Traditional (Linear Cost)
+```
+Agents | Integration Hours | Value
+1      | 10               | 1
+10     | 100              | 10  
+100    | 1,000            | 100
+1,000  | 10,000           | 1,000
+
+Cost grows linearly with agents
+```
+
+### ConnectOnion (Constant Cost)
+```
+Agents | Integration Hours | Value
+1      | 1                | 1
+10     | 1                | 10
+100    | 1                | 100  
+1,000  | 1                | 1,000
+
+Cost stays constant, value grows linearly
+```
+
+## The Real Dollar Impact
+
+### Enterprise Integration Costs
+```
+Traditional:
+- Developer: $150/hour
+- Integration: 10 hours per API
+- Cost per integration: $1,500
+- 100 integrations: $150,000
+
+ConnectOnion:
+- Initial setup: 1 hour = $150
+- All integrations: Included
+- Total cost: $150
+
+Savings: $149,850 (99.9% reduction)
+```
+
+### Opportunity Cost
+```
+Traditional:
+- 6 months integrating
+- 0 months innovating
+
+ConnectOnion:
+- 1 day integrating
+- 179 days innovating
+
+Innovation capacity: 180x increase
+```
+
+## The Behavioral Economics
+
+### Why Developers Choose Complexity
+1. **Sunk cost fallacy**: "I already learned 5 APIs..."
+2. **Control illusion**: "Custom integration = better"
+3. **Resume padding**: "Experienced with 20 APIs"
+
+### Why Simplicity Wins
+1. **Immediate value**: Works in minutes
+2. **Low commitment**: Try without investing weeks
+3. **Network effects**: Each user makes it better
+
+## The Platform Economics
+
+### Traditional Platform (Extract Value)
+```
+Platform takes: 30% revenue share
+Developer gets: 70% minus integration costs
+Net margin: Often negative initially
+```
+
+### ConnectOnion (Create Value)
+```
+Network fee: Optional premium features only
+Developer gets: 100% of direct value
+Net margin: Positive from day one
+```
+
+## The Competitive Moat
+
+### Traditional Moats (Weak)
+- API complexity (annoying but copyable)
+- User lock-in (creates resentment)
+- Feature breadth (expensive to maintain)
+
+### Behavioral Moats (Strong)
+- Network effects (more agents = more value)
+- Trust history (unfakeable, earned over time)
+- Simplicity (harder to achieve than complexity)
+
+## The Market Size Expansion
+
+### Traditional Market
+```
+Addressable developers: Those willing to integrate
+Percentage: ~5% of all developers
+Why: Most can't justify integration time
+```
+
+### ConnectOnion Market
+```
+Addressable developers: Anyone who can write a function
+Percentage: ~95% of all developers
+Why: Zero integration barrier
+
+Market expansion: 20x
+```
+
+## The Cost Waterfall
+
+### Where Traditional Costs Flow
+```
+API Complexity → Developer Time → Higher Prices → User Friction → Smaller Market
+```
+
+### Where ConnectOnion Costs Flow
+```
+Protocol Simplicity → Zero Integration → Lower Prices → User Delight → Larger Market
+```
+
+## The Unit Economics
+
+### Per-Agent Economics
+
+**Traditional**:
+- Integration cost: $1,500
+- Monthly maintenance: $100
+- Break-even: 15+ months
+- Most integrations: Never profitable
+
+**ConnectOnion**:
+- Integration cost: $0
+- Monthly maintenance: $0
+- Break-even: Immediate
+- All integrations: Profitable
+
+## The Behavioral Value Creation
+
+### Traditional (Static Value)
+```
+Agent capability: Fixed at integration time
+Value growth: Zero
+Improvement: Requires re-integration
+```
+
+### ConnectOnion (Dynamic Value)
+```
+Agent capability: Improves with use
+Value growth: Continuous
+Improvement: Automatic through behavior
+```
+
+## The Trust Economics
+
+### Traditional (Certificate-Based)
+```
+Trust cost: $100-1,000/year for certificates
+Trust value: Binary (trusted/not trusted)
+Trust growth: None
+```
+
+### ConnectOnion (Behavior-Based)
+```
+Trust cost: $0 (earned through action)
+Trust value: Continuous (0-100% scale)
+Trust growth: Increases with good behavior
+```
+
+## The Innovation Acceleration
+
+### Traditional Development Cycle
+```
+Idea → Research APIs → Integrate → Test → Deploy
+Time: 3-6 months
+Success rate: 10% (most die in integration)
+```
+
+### ConnectOnion Development Cycle
+```
+Idea → Discover agents → Compose → Deploy
+Time: 3-6 hours
+Success rate: 60% (most ideas get tested)
+
+Innovation velocity: 100x
+```
+
+## The Economic Moat Depth
+
+### Why This Can't Be Copied
+
+1. **Network effects compound daily**
+   - Each day deeper moat
+   - Each agent more valuable
+   - Each behavior more trusted
+
+2. **Simplicity is harder than complexity**
+   - Easy to add features
+   - Hard to remove them
+   - We started simple
+
+3. **Behavioral data accumulates**
+   - Can't fake history
+   - Can't buy trust
+   - Can't shortcut time
+
+## The Final Equation
+
+### Traditional Total Cost of Ownership (TCO)
+```
+TCO = ∑(Integration Cost + Maintenance + Downtime + Opportunity Cost)
+    = $1,500 × n + $100 × n × months + $losses + $missed_opportunities
+    = Grows exponentially
+```
+
+### ConnectOnion TCO
+```
+TCO = Setup Cost + (Usage × 0)
+    = $150 + 0
+    = Constant $150
+
+ROI = ∞
+```
+
+## Conclusion
+
+The revolution isn't technical - it's economic. By transforming the cost structure from O(n²) to O(1), we don't just save money. We enable entirely new categories of applications that were economically impossible before.
+
+**The future belongs to those who remove friction, not those who add features.**