# OpenManus × Kortix/Suna: side-by-side comparison and a selection guide

> **Subjects**: `FoundationAgents/OpenManus` (commit `52a13f2a`, **deepened** analysis) and `kortix-ai/suna` / product name **Kortix** (commit `5862e956`, VERSION `0.10.14`, **full checkout, deepened**, including `apps/web`)  
> **Axis**: both sit closer to commercial **Manus / Genspark**-style “general-task / research / deliverable agents” than to Claude Code-style “write code in a repo first.”  
> **Basis**: the sibling lectures *OpenManus source analysis* and *Suna source analysis*; every claim can be traced to `file:line`.  
> **Date**: 2026-07-24

---

## 1. One-line comparison

| | OpenManus | Kortix / Suna |
|---|---|---|
| **What it is** | A readable single-machine ReAct “Manus substitute” | An AI Command Center that treats the company as a Git repository |
| **Where the heart is** | In-process `Base→ReAct→ToolCall→Manus` | Platform session-lifecycle + OpenCode inside a sandbox |
| **Persistence** | Essentially no session memory (hard truncate at 100 messages) | Session sandbox + git + change request |
| **License** | MIT | Elastic License 2.0 (restricts hosting a competing product) |
| **Who it is for** | People who want to understand it in three days and fork a specialist | Teams that want to self-host a “multi-tenant AI workforce” |

---

## 2. Product-logic comparison (what the user feels)

### 2.1 User journey

**OpenManus**

1. Put a model key in `config.toml`  
2. `python main.py`, type a task  
3. The agent searches the web / opens a browser / writes files / runs Python on its own  
4. Watch the process in the terminal; deliverables land in a local directory  
5. The process exits; the next run is basically from scratch  

**Kortix/Suna**

1. `kortix init` scaffolds a company repo (`kortix.yaml` + `.kortix/opencode`)  
2. `kortix ship` to the cloud (or self-host)  
3. Open a session → an isolated sandbox clones the repo and checks out a branch named after `sessionId`  
4. Talk in Web / CLI / Slack; OpenCode does the work  
5. To keep the result → `kortix cr open` → humans review the merge → the company `main` evolves  

### 2.2 What “a deliverable” looks like

| Scenario | OpenManus is smoother | Kortix is smoother |
|---|---|---|
| “Make me a Japan travel-guide HTML” | ✅ Browser + search + local files; demo-friendly | Can do it, but cold start is heavy |
| “Fifty sales agents running outreach in parallel” | ❌ Hard to parallelize a single process | ✅ One session, one sandbox |
| “Change the company’s default agent permissions and audit them” | ❌ Edit code/config; no CR discipline | ✅ yaml + CR |
| “Understand the agent loop in three hours” | ✅ The inheritance chain is extremely short | ❌ You have to cross API / daemon / OpenCode |
| “Follow yesterday’s task in Slack” | ❌ No channel bus | ✅ Channels + `chat_threads` binding |

### 2.3 Commercial narrative

- OpenManus: **a Manus learning / prototype edition without an invite code** (README’s own wording).  
- Kortix: **a company operating system**—it refuses both “toy demo” and “rent your own company back” (MANIFESTO).

---

## 3. Technical-architecture comparison

```mermaid
flowchart TB
  subgraph OM["OpenManus"]
    I1[stdin / main.py] --> A1[Manus ToolCallAgent]
    A1 --> T1[browser / search / python / mcp]
    A1 --> M1[Memory max 100]
  end
  subgraph KX["Kortix/Suna"]
    I2[Web/CLI/Slack] --> API[apps/api session-lifecycle]
    API --> SBX[sandbox session_id==sandbox_id]
    SBX --> D[kortix-agent]
    D --> OC[opencode serve]
    OC --> EX[/v1/executor 守秘/]
    OC --> CR[change_request → main]
  end
```

| Dimension | OpenManus | Kortix/Suna |
|---|---|---|
| Language | Python 3.12 + asyncio | TypeScript / Bun monorepo |
| Main loop | `base.py` + `react.py` + `toolcall.py` | `session-lifecycle/engine.ts` + OpenCode |
| Tools | In-process ToolCollection + browser-use | Sandbox-local tools + server-side Executor |
| Permissions | Almost open; optional Docker/Daytona | IAM + grant + policy + CR |
| Multi-agent | PlanningFlow dispatches by `[AGENT]` (unstable) | Multi-sandbox parallelism + OpenCode subagent mode |
| Model access | TOML, OpenAI-compatible | LLM Gateway + `reasoning_effort` |
| Frontend | **Not a primary path** (almost terminal-only) | Web Command Center (full checkout) + SDK as SSoT |
| Extension | Add Agent classes / MCP | yaml + md + marketplace + connectors |

---

## 4. Ten decisive dimensions (for selection)

| # | Dimension | Who wins / how to choose |
|---|---|---|
| 1 | Learning curve | **OpenManus** by a mile: the inheritance chain is readable |
| 2 | Production multi-tenancy | **Kortix** by a mile: account / project / session / sandbox |
| 3 | Research + browser closed loop | **OpenManus** is more “works out of the box”; Kortix leans on OpenCode / skills |
| 4 | Long-task planning | OpenManus has PlanningFlow; Kortix relies on prompt / skills / CR cadence |
| 5 | Safe defaults | **Kortix** (secret-keeping Executor, SSRF protection); OpenManus’s browser is loose by default |
| 6 | Persistent company memory | **Kortix** (repo files + CR); OpenManus hard-truncates |
| 7 | Channels (Slack and friends) | **Kortix** |
| 8 | License freedom | **OpenManus MIT**; Kortix Elastic restricts hosted SaaS |
| 9 | Changing agent behavior | Both edit prompts; Kortix also requires yaml governance and compilation |
| 10 | Ops cost | OpenManus ≈ one script on one machine; Kortix ≈ cloud-sandbox bill + snapshot |

---

## 5. Design-philosophy contrast

| OpenManus’s bet | Kortix’s bet |
|---|---|
| “Lay Manus on the table so you can understand it in three hours” | “The company must be a cloneable source of truth” |
| Inheritance chain expresses species | session = sandbox = branch expresses isolation |
| `terminate` as a first-class exit | change request as first-class governance |
| MCP as a two-way door (light ecosystem) | Executor + Marketplace (heavy ecosystem) |

---

## 6. Selection advice (directly actionable)

1. **Course / hackathon / a vertical research agent you build yourself** → cut from **OpenManus**, or fork its ReAct chain.  
2. **A self-hosted “AI employee platform” for a team** → evaluate **Kortix** (accept Elastic and the ops complexity).  
3. **Building your own product** → take OpenManus’s **readable loop** as the MVP; when you need parallelism and governance, bring in Kortix-style **session=sandbox + CR + server-side executor**.  
4. **Do not** treat Kortix as “a textbook for learning ReAct”; **do not** treat OpenManus as “an enterprise command center.”

Draw those four rules as a “how to choose” flowchart:

```mermaid
flowchart TD
    START(["我该选哪个？"]) --> Q1{"你的目标是什么？"}
    Q1 -->|"学懂 Agent 主循环<br/>黑客松 / 垂直调研工具"| OM["✅ 选 OpenManus<br/>继承链三小时看懂<br/>MIT，随便改随便商用"]
    Q1 -->|"给团队用的<br/>自托管 AI 员工平台"| Q2{"能接受 Elastic 许可<br/>+ 云沙箱运维成本？"}
    Q2 -->|"能"| KX["✅ 选 Kortix/Suna<br/>多租户隔离 + CR 治理"]
    Q2 -->|"不能"| MVP["先用 OpenManus 做 MVP<br/>日后真需要治理再迁"]
    Q1 -->|"自己造产品"| BOTH["🔀 两头取<br/>用 OpenManus 的可读循环起步<br/>需要并行/治理时，再加<br/>会话=沙箱 + CR + 守秘执行器"]
    style OM fill:#e7f8f1
    style KX fill:#eaf1ff
    style BOTH fill:#fff3df
    style MVP fill:#fff3df
```

> 🧠 **One sentence**: want to read it in three days and fork your own specialist → OpenManus; want to self-host an “AI workforce” and keep it under control → Kortix. Same axis (general task / research / deliverable); the gap is scale and governance, not direction.

---

## 7. Coordinates against the rest of this series

```text
write-code-first ──────────────────────────── general-task / research-first
Claude Code / opencode / goose              OpenManus · Kortix/Suna
                                              ↑ the main axis of this comparison

personal IM butler ─────────────────────────── company OS
nanobot / Raven                              Kortix/Suna
```

*End of lecture. Companion learning station: `openmanus-suna-learn/`; the from-scratch tutorial is the parent-directory file `从零构建通用任务Agent-Manus系-开发全流程教程.md`.*