Mitos

आपके AI एजेंटों के लिए पृथक, फोर्क करने योग्य कंप्यूटर।
Kubernetes पर मिलीसेकंड microVM सैंडबॉक्स फोर्किंग: एक चालू VM को समानांतर प्रयासों में फोर्क करें और दसियों मिलीसेकंड में मेमोरी से पुनर्स्थापित करें।

त्वरित आरंभ . दस्तावेज़ . विशेषताएँ . तुलना . योगदान . समुदाय

Mitos SDK: एक microVM सैंडबॉक्स बनाएँ, कोड चलाएँ, और इसे पृथक समानांतर प्रयासों में फोर्क करें

Mitos क्या है

Mitos हर AI एजेंट को अपना खुद का पृथक कंप्यूटर देता है: एक हार्डवेयर-पृथक Firecracker microVM जो अविश्वसनीय कोड को सुरक्षित रूप से चलाता है और जिसे चलते समय आप फोर्क कर सकते हैं। एक लाइव copy-on-write फोर्क एक गर्म VM को दसियों मिलीसेकंड में N स्वतंत्र बहनों में विभाजित करता है, ताकि एक एजेंट साझा, तैयार स्थिति से कई प्रयासों को समानांतर रूप से खोज सके, और आप केवल उन पेजों के लिए भुगतान करें जिन्हें प्रत्येक बहन बदलती है।

इसे आज अपने खुद के Kubernetes क्लस्टर पर चलाएँ, जहाँ आपके एजेंटों का कोड, डेटा और क्रेडेंशियल कभी भी आपके इंफ्रास्ट्रक्चर से बाहर नहीं जाते, या बिना किसी नोड के प्रबंधन के होस्टेड API पर चलाएँ। जहाँ तक हम जानते हैं, यह एकमात्र रनटाइम है जो ओपन सोर्स, सेल्फ-होस्ट करने योग्य, Kubernetes-नेटिव और एक चालू VM को लाइव-फोर्क करने में सक्षम है, यह सब एक साथ।

त्वरित आरंभ

1. इंस्टॉल करें और प्रमाणित करें```bash

pip install mitos-run export MITOS_API_KEY=sk-... # a key from https://mitos.run; no Kubernetes required

SDK डिफ़ॉल्ट रूप से होस्ट किए गए एंडपॉइंट का उपयोग करता है। `MITOS_BASE_URL` सेट करके वही कोड आपके अपने क्लस्टर या स्टैंडअलोन सैंडबॉक्स-सर्वर पर चलता है। कुंजी तर्क या `MITOS_API_KEY` से प्राप्त की जाती है और इसे कभी लॉग नहीं किया जाता।

### 2. सैंडबॉक्स बनाएँ और कोड चलाएँ```python
import mitos

sb = mitos.create("python")                  # Ready microVM sandbox (~27 ms warm-claim)
print(sb.exec("echo hello").stdout)          # hello

# Files and a stateful code interpreter hang off the same flat handle.
sb.files.write("/workspace/plan.txt", "draft")
print(sb.run_code("import math; math.sqrt(144)").text)   # 12.0

पूर्ण संदर्भ: mitos.run/docs/quickstart.

3. समानांतर प्रयासों में फोर्क करें```python

N-way copy-on-write fork of the live VM: each sibling lands warm and independent.

a, b = sb.fork(2) a.exec("echo conservative > /workspace/plan.txt") b.exec("echo aggressive > /workspace/plan.txt")

sb.terminate()

एसिंक क्लाइंट समान सतह को दर्शाता है: `await mitos.aio.create("python")` उसी `exec` / `run_code` / `files` / `create_pty` / `fork` / `terminate` के साथ एक `AsyncDirectSandbox` लौटाता है।

ब्लॉकिंग `exec` और `run_code` husk डिफ़ॉल्ट पर काम करते हैं। स्ट्रीमिंग exec (`sb.exec(..., on_stdout=...)`), बैकग्राउंड प्रोसेस (`sb.exec_background(...)`), और इंटरैक्टिव PTY (`sb.create_pty()`) आज इंजन पथ पर चलते हैं और उन्हें husk डिफ़ॉल्ट पर लाया जा रहा है; `run_code` तब तक एक फेल-क्लोज़ `KernelUnavailable` लौटाता है जब तक कर्नेल husk बेस इमेज में शामिल नहीं हो जाता।

### इसे अपने तरीके से चलाएँ

वही इंजन, वही API, अधिक प्रवेश बिंदु। गहराई के लिए [दस्तावेज़](https://mitos.run/docs) पर एक क्लिक।

**हर भाषा, दो मोड।** प्रत्येक SDK **direct mode** (स्टैंडअलोन या होस्टेड) में एक ही सैंडबॉक्स-सर्वर REST API से बात करता है, और प्रत्येक के पास **cluster mode** भी है (एक `AgentRun` जो Kubernetes API के माध्यम से `mitos.run/v1` CRDs को चलाता है)। डिफ़ॉल्ट-पूल नामकरण सभी छह में बाइट-दर-बाइट समान है।

| भाषा | स्थापना | Direct | Cluster | SDK दस्तावेज़ |
|---|---|---|---|---|
| Python | `pip install mitos-run` | sync + async | `AgentRun` | [sdk/python](https://github.com/mitos-run/mitos/blob/HEAD/sdk/python) |
| TypeScript | `npm i @mitos/sdk` | हाँ | `AgentRun` | [sdk/typescript](https://github.com/mitos-run/mitos/blob/HEAD/sdk/typescript/README.md) |
| Go | `go get github.com/mitos-run/mitos/sdk/go` | टाइप्ड, `errors.Is`-अनुकूल | `AgentRun` | [sdk/go](https://github.com/mitos-run/mitos/blob/HEAD/sdk/go/README.md) |
| Ruby | gem (केवल stdlib) | हाँ | `AgentRun` | [sdk/ruby](https://github.com/mitos-run/mitos/blob/HEAD/sdk/ruby/README.md) |
| Rust | crate (ब्लॉकिंग) | हाँ | `AgentRun` | [sdk/rust](https://github.com/mitos-run/mitos/blob/HEAD/sdk/rust/README.md) |
| Java | JDK 17 (केवल stdlib) | हाँ | `AgentRun` | [sdk/java](https://github.com/mitos-run/mitos/blob/HEAD/sdk/java/README.md) |

Go SDK अपने स्वयं के नेस्टेड मॉड्यूल (`github.com/mitos-run/mitos/sdk/go`) में आता है, इसलिए इसे आयात करने से आपके बिल्ड में कभी भी कंट्रोलर नहीं आता।

**सेल्फ-होस्टिंग? वही कोड।** Helm चार्ट उसी गेटवे को तैनात करता है जिसे होस्टेड सेवा चलाती है, इसलिए ऊपर दिया गया क्विकस्टार्ट आपके अपने क्लस्टर पर बिना बदलाव के काम करता है: `MITOS_BASE_URL` को अपने गेटवे पर इंगित करें और बाकी सब कुछ वैसे ही रखें। होस्टेड और सेल्फ-होस्टेड एक ही अनुभव हैं; केवल URL और इसे संचालित करने वाला अलग होता है।

**Kubernetes-नेटिव नियंत्रण, जब चाहें।** उन प्लेटफ़ॉर्म टीमों के लिए जो पूल को घोषणात्मक रूप से प्रबंधित करती हैं (GitOps, RBAC-स्कोप्ड ऑटोमेशन, ऑपरेटर), दो-स्तरीय `AgentRun` पथ गेटवे को छोड़ देता है और Kubernetes API के माध्यम से सीधे `mitos.run/v1` CRDs को चलाता है:```python
from mitos import AgentRun

c = AgentRun()                                   # kubeconfig or in-cluster; autodetected
sb = c.sandbox("python", ready=True)             # claims a warm sandbox, waits Ready
print(sb.exec("python -c 'print(40 + 2)'").stdout)   # 42

fork_a, fork_b = sb.fork(2)                       # fork against shared warmed state
sb.terminate()

c.sandbox("python") यदि आपके पास कोई पूल नहीं है तो आलसी ढंग से एक डिफ़ॉल्ट पूल बनाता है; किसी मौजूदा पूल का उपयोग करने के लिए pool="my-pool" पास करें। त्रुटियाँ AgentRunError(code, cause, remediation) उत्पन्न करती हैं। AsyncAgentRun हॉट पाथ (hot paths) को प्रतिबिंबित करता है और WebSocket पर create_pty() जोड़ता है।

CLI और MCP.

mitos CLI होस्टेड गेटवे (क्लस्टर की आवश्यकता नहीं) या आपके अपने Kubernetes क्लस्टर के साथ काम करता है:```bash go install mitos.run/mitos/cmd/mitos@latest # requires a Go toolchain

Hosted mode: set MITOS_API_KEY, no kubeconfig required.

export MITOS_API_KEY=sk-... mitos sandbox create --pool python # create from the python template mitos sandbox exec "python3 -c 'print(42)'" mitos fork --count 2 # fork into 2 independent siblings mitos sandbox ls mitos sandbox terminate

Cluster mode (kubeconfig): target your own Kubernetes nodes.

mitos sandbox create --pool dev-default mitos run echo hello --pool dev-default

`mitos dev up` एक-कमांड लोकल कंट्रोल प्लेन को मॉक इंजन पर चालू करता है, जो
क्लस्टर-मोड विकास के लिए है। एक MCP सर्वर (`mitos-mcp`) सैंडबॉक्स को MCP
टूल के रूप में किसी भी MCP-भाषी एजेंट के लिए उजागर करता है, और एक [एजेंट स्किल](https://github.com/mitos-run/mitos/blob/HEAD/skills/mitos/SKILL.md)
स्किल-सक्षम एजेंटों को यह वर्कफ़्लो सिखाता है। पूरा इंस्टॉल मैट्रिक्स (स्क्रिप्ट,
Homebrew, deb/rpm, scoop/winget, checksums) यहाँ उपलब्ध है:
[mitos.run/docs/install](https://mitos.run/docs/install).

**अपने पहले से उपयोग किए जा रहे एजेंट में सीधे शामिल हों।** हर अडैप्टर उन्हीं नेटिव ops (`exec`, `run_code`, `files`, `fork`) के ऊपर एक पतला शिम है, जिसकी फ्रेमवर्क पैकेज पर कोई कठोर निर्भरता नहीं है: Claude Code और opencode (MCP सर्वर + एजेंट स्किल), OpenAI Agents SDK, Claude Agent SDK, LangChain / deepagents, Vercel AI SDK / Pydantic AI / AutoGen / LlamaIndex (स्टैंडर्ड MCP), और "एक इम्पोर्ट बदलें" माइग्रेशन शिम, उन टीमों के लिए जो [E2B](https://mitos.run/docs/migrating-from-e2b) या [Daytona](https://mitos.run/docs/migrating-from-daytona) क्लाउड छोड़ रही हैं। [इंटीग्रेशन हब](https://github.com/mitos-run/mitos/blob/HEAD/docs/integrations/README.md) हर मार्ग को अनुक्रमित करता है।

**ऑपरेटर इंस्टॉल करें।**```bash
kubectl apply -k deploy/

स्व-निहित kustomize base CRDs, controller (husk mode), forkd DaemonSet, /dev/kvm device plugin, और PKI bootstrap स्थापित करता है, और बिना किसी मैनुअल पैच के एक वास्तविक KVM नोड पर लागू होता है. Helm chart GHCR पर OCI रजिस्ट्री में प्रकाशित है: helm install mitos oci://ghcr.io/mitos-run/charts/mitos --version 1.42.1; देखें deploy/charts/mitos. फिर एक warm pool घोषित करें, और उससे Sandbox के साथ fork करें जिसका source.fromSandbox एक live session की ओर इंगित करता है (templates):```yaml apiVersion: mitos.run/v1 kind: SandboxPool metadata: name: python-agent-pool spec: template: image: python:3.12-slim init: ["pip install numpy pandas requests"] resources: { cpu: "1", memory: "512Mi" } volumes: - { name: workspace, size: 5Gi, forkPolicy: Snapshot } warm: { min: 10 }

**यह कहाँ चलता है।** एकमात्र नोड आवश्यकता `/dev/kvm` के साथ-साथ लेबल `mitos.run/kvm=true` है, इसलिए mitos किसी भी Kubernetes क्लस्टर पर इंस्टॉल हो जाता है जिसमें बेयर-मेटल या नेस्टेड-वर्चुअलाइजेशन KVM नोड्स हों:

| प्लेटफ़ॉर्म | KVM नोड | गाइड |
|---|---|---|
| बेयर मेटल (Talos, Hetzner) | नेटिव `/dev/kvm` | [docs/platforms/talos-hetzner.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/platforms/talos-hetzner.md) (प्रथम श्रेणी का संदर्भ) |
| AWS / EKS | `*.metal` या नेस्टेड-वर्ट नोड ग्रुप | आज के लिए सामान्य चार्ट; प्रति-क्लाउड गाइड issue [#919](https://github.com/mitos-run/mitos/issues/919) है |
| GKE | नेस्टेड-वर्चुअलाइजेशन नोड पूल | आज के लिए सामान्य चार्ट; प्रति-क्लाउड गाइड [#919](https://github.com/mitos-run/mitos/issues/919) है |
| Azure / AKS | नेस्टेड-वर्चुअलाइजेशन-सक्षम VM आकार | आज के लिए सामान्य चार्ट; प्रति-क्लाउड गाइड [#919](https://github.com/mitos-run/mitos/issues/919) है |

चार्ट और CRDs उन सभी जगह समान हैं; केवल वह नोड पूल अलग है जो `/dev/kvm` उपलब्ध कराता है।

## Mitos क्यों

एजेंट हार्नेस को तेज़, अलग-थलग वातावरण चाहिए जहाँ एजेंट फ़ाइलें पढ़ और लिख सकें, पैकेज इंस्टॉल कर सकें, और अविश्वसनीय कोड चला सकें। हर मौजूदा विकल्प एक समझौता थोपता है: स्वामित्व के बिना गति, फोर्किंग के बिना अलगाव, वार्म स्टार्ट के बिना Kubernetes-नेटिव, या किसी और के क्लाउड के अंदर बंद स्थायित्व।

- **चल रहे VM को लाइव-फोर्क करें।** लाइव microVM का N-वे कॉपी-ऑन-राइट फोर्क: बेटी VMs तब तक पैरेंट के मेमोरी पेज साझा करती हैं जब तक वे लिखती नहीं हैं, इसलिए हर फोर्क एक वार्म, तैयार वातावरण में पहुँचता है। एक एजेंट को कई समानांतर प्रयासों में शाखा करें।
- **~27 ms वार्म-क्लेम सक्रियण।** Firecracker microVMs एक मेमोरी स्नैपशॉट से दसियों-मिलीसेकंड की श्रेणी में रिस्टोर होते हैं: बेयर-मेटल संदर्भ नोड पर P50 ~27 ms, जिसे [`bench/husk-activate-latency.sh`](https://github.com/mitos-run/mitos/blob/HEAD/bench/husk-activate-latency.sh) से पुनः उत्पन्न किया जा सकता है।
- **ओपन सोर्स, सेल्फ-होस्ट करने योग्य, Kubernetes-नेटिव।** जहाँ तक हम जानते हैं, एकमात्र रनटाइम जो तीनों करता है। आप पूरे जीवनचक्र को डिक्लेरेटिव CRDs (`mitos.run`) के माध्यम से संचालित करते हैं।

इसे चलाने के दो तरीके:

- **सेल्फ-होस्टेड (आज):** कोई भी Kubernetes क्लस्टर जिसमें KVM नोड्स हों। आपका डेटा कभी आपके इन्फ्रास्ट्रक्चर से बाहर नहीं जाता। बेयर मेटल (Talos + Hetzner) प्रथम श्रेणी का संदर्भ प्लेटफ़ॉर्म है।
- **होस्टेड (प्रगति पर):** वही इंजन और API जो हमारे द्वारा संचालित है, उन टीमों के लिए जो नोड्स प्रबंधित किए बिना मिलीसेकंड चाहती हैं।

> दो इंजन पथ मौजूद हैं। **husk पॉड-नेटिव पथ डिफ़ॉल्ट है**: प्रत्येक VM अपने स्वयं के अनप्रिविलेज्ड पॉड में चलता है, और स्रोत husk पॉड अपने चल रहे VM का स्नैपशॉट लेता है ताकि N चाइल्ड पॉड इसे CoW के माध्यम से रिस्टोर करें। **raw-forkd पथ** forkd के इन-प्रोसेस इंजन में फोर्क चलाता है। यहाँ सब कुछ husk डिफ़ॉल्ट पर चलता है जब तक स्पष्ट रूप से `engine path` चिह्नित न किया जाए।

सैंडबॉक्स पॉड नहीं हैं। पॉड-स्कोप्ड Kubernetes तंत्र (NetworkPolicy, ResourceQuota, PSA) husk पॉड को नियंत्रित करते हैं, microVM के अंदर के वर्कलोड को नहीं; सैंडबॉक्स VM है, husk पॉड नहीं, और जहाँ हम समकक्ष सुविधा प्रदान करते हैं, उसे हमारे रूप में प्रलेखित किया गया है। पूर्ण claim और exec डेटा पथ तथा घटक आरेख [mitos.run/docs/architecture](https://mitos.run/docs/architecture) पर हैं।

## बेंचमार्क

यहाँ का हर आँकड़ा वास्तविक KVM हार्डवेयर पर [`bench/`](https://github.com/mitos-run/mitos/blob/HEAD/bench/) से पुनः उत्पन्न करने योग्य है; ऐसा कुछ भी प्रकाशित नहीं है जिसे पाठक पुनः उत्पन्न न कर सके (परियोजना का "असत्यापित दावे नहीं" नियम)। प्रत्येक पंक्ति बताती है कि वह क्या मापती है और उसे पुनः उत्पन्न करने वाला सटीक कमांड। पूर्ण प्रति-रन डेटा और हार्डवेयर संदर्भ [`bench/results/`](https://github.com/mitos-run/mitos/blob/HEAD/bench/results/) में हैं।

### होस्टेड टाइम-टू-इंटरैक्टिव, ComputeSDK पीयर सेट की तुलना में

टाइम टू इंटरैक्टिव (TTI) एकमात्र आँकड़ा है जो सार्वजनिक [ComputeSDK benchmark](https://github.com/computesdk/benchmarks) के साथ सीधे तुलनीय (apples-to-apples) है, जिसके विरुद्ध हर होस्टेड सैंडबॉक्स विक्रेता को मापा जाता है: घड़ी `create()` पर शुरू होती है और तब रुकती है जब कोई कमांड वास्तव में सैंडबॉक्स के अंदर चलकर लौट चुका होता है।

| प्रदाता | TTI P50 | माप |
|---|---|---|
| northflank | 95.9 ms | ComputeSDK प्रकाशित |
| **mitos** | **96.8 ms** | हमारा हार्नेस, `api.mitos.run` |
| daytona | 136.2 ms | ComputeSDK प्रकाशित |
| e2b | 365.6 ms | ComputeSDK प्रकाशित |

हमारा आँकड़ा और पीयर तालिका पुनः उत्पन्न करें (पीयर संख्याएँ ComputeSDK द्वारा प्रकाशित अपरिवर्तनीय कमिट से पढ़ी गई हैं, हमारे द्वारा दोबारा नहीं चलाई गईं):```sh
MITOS_API_KEY=... python3 bench/tti-latency.py 100        # our TTI, N=100
python3 bench/peer-tti.py --date 2026-07-09 \
  --ref 3eddee1a972bd49aea56fd6c16d238ca0a45dece            # the peer table

इसे उन चेतावनियों के साथ पढ़ें जिन्हें पूरा रिकॉर्ड बताता है और छिपाता नहीं है: यह उनके प्रकाशित आंकड़ों के मुकाबले हमारा हार्नेस है, उनके लीडरबोर्ड में मापी गई स्थिति नहीं; यह अनुक्रमिक रन है (एक समवर्ती बर्स्ट आज के सिंगल-नोड वार्म पूल को खत्म कर देगा, issue #586); और वास्तविक लीडरबोर्ड रैंक का दावा करने के लिए computesdk/computesdk एडेप्टर (issue #891) शिप करना आवश्यक है। इन सीमाओं के भीतर, होस्टेड mitos Daytona से नीचे और Northflank के बराबर है, 100/100 सफल इटरेशन।

अपने क्लस्टर के अंदर फोर्किंग (एक एजेंट सबएजेंट स्पॉन कर रहा है)

जब कोई एजेंट आपके क्लस्टर में चलता है और खुद को समानांतर प्रयासों में शाखाबद्ध करता है, तो मायने रखने वाली लागत fork-to-first-exec है: लाइव-VM फोर्क से चाइल्ड में कमांड लौटने तक का वॉल-क्लॉक समय। उसी इन-प्रोसेस इंजन से मापा गया जिसे forkd चलाता है:

पूर्ण विधि और हार्डवेयर [bench/README.md](https://github.com/mitos-run/mitos/blob/HEAD/bench/README.md) में; परिणाम [2026-06-19-bare-metal-fork-exec.md](https://github.com/mitos-run/mitos/blob/HEAD/bench/results/2026-06-19-bare-metal-fork-exec.md) और [2026-06-21-kvm-perf-correctness.md](https://github.com/mitos-run/mitos/blob/HEAD/bench/results/2026-06-21-kvm-perf-correctness.md) में।

### वार्म-क्लेम एक्टिवेट (इंजन, राउंड ट्रिप नहीं)

इंजन का अपना वार्म-सैंडबॉक्स एक्टिवेट (स्नैपशॉट लोड + फोर्क-शुद्धता हैंडशेक + गेस्ट-रेडी) बेयर-मेटल संदर्भ नोड पर P50 ~27 ms है, जिसे [`bench/husk-activate-latency.sh`](https://github.com/mitos-run/mitos/blob/HEAD/bench/husk-activate-latency.sh) से पुन: उत्पन्न किया जा सकता है। यह ऊपर बताए गए एंड-टू-एंड होस्टेड TTI से छोटी और अलग संख्या है; किसी प्रतिस्पर्धी के create-API आंकड़े के मुकाबले इंजन का आंकड़ा उद्धृत करना एक श्रेणीगत त्रुटि होगी, इसलिए हम इन्हें अलग रखते हैं।

## विशेषताएँ

husk पॉड-नेटिव पथ डिफ़ॉल्ट है। कुछ क्षमताएँ आज केवल raw-forkd `engine path` पर चलती हैं और उन्हें चिह्नित किया गया है, साथ में ट्रैकिंग इश्यू का लिंक भी है।

### गति

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| वार्म-क्लेम एक्टिवेट | बेयर-मेटल संदर्भ नोड पर P50 ~27 ms (स्नैपशॉट लोड + फोर्क-शुद्धता हैंडशेक + गेस्ट-रेडी); ~6-16 ms स्नैपशॉट रिस्टोर; CoW पेज साझाकरण के माध्यम से प्रति फोर्क ~3 MiB सीमांत मेमोरी | [BENCHMARKS.md](https://github.com/mitos-run/mitos/blob/HEAD/BENCHMARKS.md) |
| प्री-स्नैपशॉटेड पूल | OCI इमेजें ext4 rootfs में फ्लैट की जाती हैं और स्नैपशॉट लेने से पहले आपके `init` चरणों के साथ वार्म की जाती हैं, ताकि क्लेम पर कोई कोल्ड स्टार्ट न हो | [docs/templates.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/templates.md) |
| CoW मेमोरी साझाकरण | आप फोर्क्स के बीच अद्वितीय पेजों के लिए भुगतान करते हैं, प्रतियों के लिए नहीं | [mitos.run/docs/metering](https://mitos.run/docs/metering) |
| कंटेंट-एड्रेस्ड वितरण | फोर्क्स mTLS के ऊपर किसी होल्डर से केवल लापता sha256 चंक खींचते हैं; पुनर्निर्माण संस्करण-संगतता अनुबंध के तहत डेल्टा भेजते हैं | [docs/snapshot-distribution.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/snapshot-distribution.md) |

### अलगाव

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| प्रति सत्र हार्डवेयर अलगाव | प्रति सैंडबॉक्स एक समर्पित कर्नेल (KVM/Firecracker); husk डिफ़ॉल्ट पर प्रत्येक VM अपने स्वयं के अनप्रिविलेज्ड, PSA-प्रतिबंधित पॉड में चलता है, जो प्रति-VM सीमा है | [mitos.run/docs/threat-model](https://mitos.run/docs/threat-model) |
| कोई मौन गोपनीय-विरासत नहीं | गोपनीय डेटा रखने वाले सैंडबॉक्स के लाइव फोर्क्स को तब तक अस्वीकार किया जाता है जब तक स्पष्ट रूप से ऑप्ट-इन न किया गया हो; क्रेडेंशियल क्लेम समय पर vsock के ऊपर इंजेक्ट किए जाते हैं, कभी भी स्नैपशॉट में अंतर्निहित नहीं किए जाते | [mitos.run/docs/threat-model](https://mitos.run/docs/threat-model) |
| डिफ़ॉल्ट-अस्वीकार ईग्रेस | पॉड के अपने netns में एक इन-पॉड nftables डिफ़ॉल्ट-अस्वीकार फ़िल्टर (CNI-स्वतंत्र), एक बिना शर्त क्लाउड-मेटाडेटा (169.254.169.254) ब्लॉक और इन-पॉड DNS प्रॉक्सी के माध्यम से IP:port और नाम द्वारा प्रति-टेम्पलेट अनुमतिसूची के साथ। वास्तविक KVM क्लस्टर पर एंड-टू-एंड सत्यापित; गेस्ट प्रवर्तन को प्रभावित नहीं कर सकता | [mitos.run/docs/networking](https://mitos.run/docs/networking) |
| रेस्ट पर एन्क्रिप्शन | क्रिप्टो-श्रेडिंग और KMS एनवलप रैपिंग वाले प्रति-स्कोप LUKS2 कंटेनर (`--enable-encryption` के पीछे, फेल-क्लोज्ड); HSM-समर्थित कुंजियाँ और प्रति-वर्कस्पेस स्कोप अनुवर्ती कार्य हैं | [docs/encryption.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/encryption.md) |

### एजेंट DX

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| ब्लॉकिंग exec | सैंडबॉक्स API के ऊपर सही stdout और एग्ज़िट कोड | [mitos.run/docs/cli](https://mitos.run/docs/cli) |
| स्ट्रीमिंग exec और PTY | इंक्रीमेंटल stdout/stderr, बैकग्राउंड प्रोसेस, और टोकन-गेटेड इंटरैक्टिव WebSocket टर्मिनल (`engine path`) | [mitos.run/docs/cli](https://mitos.run/docs/cli) |
| कोड इंटरप्रेटर | हर SDK और MCP सर्वर में स्टेटफुल कर्नेल और समृद्ध मल्टी-MIME परिणामों के साथ `run_code`; जब तक कर्नेल husk बेस इमेज में नहीं आ जाता, फेल-क्लोज्ड `KernelUnavailable` | [mitos.run/docs/mcp](https://mitos.run/docs/mcp) |
| LLM-पठनीय त्रुटियाँ | हर विफलता `{code, cause, remediation}` लेकर आती है, जिसे SDK संरचित `AgentRunError` में पार्स करते हैं | [docs/api/errors.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/api/errors.md) |

### Kubernetes-नेटिव

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| डिक्लेरेटिव CRDs | `mitos.run/v1` में `SandboxPool`, `Sandbox` (poolRef/fromSandbox/fromRevision स्रोत), `Workspace`/`WorkspaceRevision` वॉल्यूम टोपोलॉजी और फोर्क व्यवहार के साथ | [docs/templates.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/templates.md) |
| पॉड-नेटिव निष्पादन | प्रत्येक प्रति-सैंडबॉक्स VM एक अनप्रिविलेज्ड पॉड में चलता है (`/dev/kvm` एक डिवाइस प्लगइन से, `privileged` नहीं), इसलिए CPU/मेमोरी अनुरोध शेड्यूलर सत्य हैं और PSA पॉड को नियंत्रित करता है | [mitos.run/docs/threat-model](https://mitos.run/docs/threat-model) |
| क्षमता-जागरूक शेड्यूलिंग | वार्म होल्डर्स पर CoW बिन-पैकिंग, एक CoW-जागरूक ओवरकमिट बजट, परमाणु स्लॉट आरक्षण के साथ `MaxSandboxes` होस्ट-DoS सीमा, और नोड को OOM करने के बजाय टाइप्ड `NoCapacity` बैकप्रेशर | [docs/scheduling.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/scheduling.md) |
| माँग-संचालित ऑटोस्केलिंग | `SandboxPool.spec.autoscale` निष्क्रिय husk-पॉड संख्या को एंटी-थ्रैश कूलडाउन के साथ `clamp(inUse + targetSpare, minWarm, maxWarm)` तक स्केल करता है; एक निश्चित पूल केवल `minWarm == replicas` है | [docs/scheduling.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/scheduling.md) |
| विफलता और GC सेमेन्टिक्स | क्लेम TTLs, अनाथ-VM स्वीप, कंट्रोलर-रिस्टार्ट रिकंसिलिएशन, ऑन-डिस्क जर्नल के माध्यम से forkd क्रैश रीपिंग, नोड-हानि हैंडलिंग, और संतृप्ति बैकप्रेशर, सभी CI-सिद्ध | [docs/failure-gc.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/failure-gc.md) |

### टिकाऊ स्थिति

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| टिकाऊ फोर्केबल वर्कस्पेस | `Workspace`/`WorkspaceRevision` CRDs: किसी भी सैंडबॉक्स से स्वतंत्र टिकाऊ, संस्करणित, फोर्केबल एजेंट स्थिति। `/workspace` स्टार्ट पर हाइड्रेट होता है और एक प्रतिबद्ध रिवीजन कंटेंट-एड्रेस्ड स्टोर के ऊपर टर्मिनेट पर डिहाइड्रेट होता है। वास्तविक KVM क्लस्टर पर create -> commit -> fork सत्यापित | [mitos.run/docs/workspaces](https://mitos.run/docs/workspaces) |
| आउटपुट और diff | `spec.lifetime.onTerminate.outputs` डिहाइड्रेट को सूचीबद्ध सबट्री तक सीमित करता है; `{diff: true}` पैरेंट हेड के मुकाबले कंटेंट-हैश diff रिकॉर्ड करता है | [mitos.run/docs/workspaces](https://mitos.run/docs/workspaces) |
| Git रेंडेज़वस | एक `{git}` आउटपुट प्रति-प्रयास ब्रांच को रेंडेज़वस रिमोट पर पुश करता है (इंजन पुश करता है; एक इंसान या CI मर्ज करता है)। आज husk पर बेस्ट-एफर्ट | [mitos.run/docs/workspaces](https://mitos.run/docs/workspaces) |
| डेव-वातावरण URL | `mitos workspace serve <ws> --pool P` वर्कस्पेस से बंधे एक फोर्क्ड सैंडबॉक्स को वार्म-क्लेम करता है और एक तैयार `https://<label>.<expose-domain>/` URL लौटाता है; प्रत्येक फोर्क्ड सत्र को अपना स्वयं का URL मिलता है | [docs/recipes/dev-environment.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/recipes/dev-environment.md) |

### संचालन योग्य

| क्षमता | आपको क्या मिलता है | दस्तावेज़ |
|---|---|---|
| मेट्रिक्स और ट्रेसिंग | नोड और कंट्रोलर Prometheus मेट्रिक्स, एक प्रति-क्लेम OpenTelemetry ट्रेस (`--otlp-endpoint`), और एक टॉगल करने योग्य संरचित ऑडिट लॉग (`--audit-log`) जो कमांड/पथ और बाइट गणना रिकॉर्ड करता है, कभी भी सामग्री या गोपनीय डेटा नहीं | [mitos.run/docs/observability](https://mitos.run/docs/observability) |
| CoW-जागरूक मीटरिंग | साझा टेम्पलेट पेज सेट एक बार गिना जाता है, प्रति फोर्क नहीं, इसलिए बिलिंग और शेड्यूलिंग ईमानदार भौतिक पदचिह्न को दर्शाते हैं | [mitos.run/docs/metering](https://mitos.run/docs/metering) |
| ऑपरेटर टूलिंग | `kubectl mitos` प्लगइन (`ls` / `ps`) और ऑपरेशनल `GET /v1/metering` रिपोर्ट | [mitos.run/docs/observability](https://mitos.run/docs/observability) |
| बेयर मेटल प्रथम-श्रेणी | Talos + Hetzner संदर्भ प्लेटफ़ॉर्म है | [docs/platforms/talos-hetzner.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/platforms/talos-hetzner.md) |
| एकल-उपयोगकर्ता प्रथम रन | एक-उपयोगकर्ता लॉगिन गेट के साथ k3s क्विकस्टार्ट (केवल QA, प्रोडक्शन नहीं) | [docs/platforms/k3s-quickstart.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/platforms/k3s-quickstart.md) |

## तुलना

हेड-टू-हेड संख्या तालिका यहाँ केवल तभी उचित है जब हमारा हार्नेस इस रिपॉजिटरी में स्क्रिप्ट के साथ, समान हार्डवेयर पर वास्तविक प्रतिस्पर्धियों के मुकाबले इसे पुन: उत्पन्न कर सके। वह हार्नेस [#15](https://github.com/mitos-run/mitos/issues/15) है। नीचे दिए गए आंकड़े **अन्य विक्रेताओं के प्रकाशित आंकड़े हैं, विभिन्न ऑपरेशनों के लिए, विभिन्न हार्डवेयर पर, विभिन्न पद्धति के साथ**: वे हमारे द्वारा मापे नहीं गए हैं और हेड-टू-हेड दावा नहीं हैं।

| रनटाइम | प्रकाशित आंकड़ा (उनका, हमारा नहीं) | जिस ऑपरेशन का वे वर्णन करते हैं |
|---|---|---|
| Mitos (हमारा, मापा गया) | ~27 ms P50 | बेयर-मेटल संदर्भ नोड पर वार्म-क्लेम एक्टिवेट |
| E2B | ~150 ms | सैंडबॉक्स create |
| Daytona | sub-90 ms | स्नैपशॉट से create |
| Modal | sub-second | सैंडबॉक्स create |
| CodeSandbox SDK | ~863 ms / ~495 ms | लाइव फोर्क / मेमोरी-रिज़्यूम |
| Fly Machines | < 1 s | मशीन स्टार्ट |

आज जो तुलनीय और वास्तविक है वह गुणात्मक पेरेटो मैप है: ओपन सोर्स, सेल्फ-होस्टेबल, k8s-नेटिव और लाइव स्नैपशॉट फोर्क का संयोजन वह धुरी है जहाँ Mitos अकेला है।

| | Mitos | E2B | Modal | Daytona | Morph | Cloudflare | Box | Agent Sandbox | Kata/KubeVirt | raw Firecracker |
|---|---|---|---|---|---|---|---|---|---|---|
| प्रति सत्र हार्डवेयर अलगाव | KVM microVM | microVM | gVisor | कंटेनर/VM | microVM | V8 isolate | VM | Kata विकल्प | KVM | KVM |
| चालू स्थिति का स्नैपशॉट फोर्क | हाँ, मुख्य प्राइमिटिव | snapshot/resume | मेमोरी स्नैपशॉट | नहीं | हाँ (Infinibranch) | नहीं | डिस्क फोर्क | नहीं | नहीं | DIY |
| वार्म-पूल मिलीसेकंड क्लेम | हाँ (डिज़ाइन केंद्र) | वार्म पूल | वार्म पूल | वर्कस्पेस | हाँ | इंस्टेंट आइसोलेट्स | प्रकाशित नहीं | 1-3s कोल्ड | सेकंड | DIY |
| टिकाऊ फोर्केबल वर्कस्पेस | Workspace CRD | नहीं | वॉल्यूम | वर्कस्पेस | हाँ, प्रोप्राइटरी | हाँ (डिस्क) | नहीं | PVCs | PVCs | नहीं |
| Kubernetes-नेटिव API | CRDs | SaaS API | SaaS API | SaaS/OSS | SaaS API | SaaS API | agent-native CLI | CRDs | CRDs | नहीं |
| सेल्फ-होस्टेबल | हाँ, कोई भी KVM क्लस्टर | आंशिक OSS | नहीं | OSS कोर | नहीं | नहीं | नहीं | हाँ | हाँ | हाँ |
| होस्टेड विकल्प | योजनाबद्ध (समान इंजन) | हाँ | हाँ | हाँ | हाँ | हाँ | हाँ (केवल) | नहीं | नहीं | नहीं |
| आपका डेटा आपके इन्फ्रा पर रहता है | हाँ (सेल्फ-होस्टेड) | नहीं | नहीं | आंशिक | नहीं | नहीं | नहीं | हाँ | हाँ | हाँ |
| ओपन सोर्स | Apache 2.0 | आंशिक | नहीं | आंशिक | नहीं | नहीं | नहीं | Apache 2.0 | Apache 2.0 | Apache 2.0 |

SaaS रनटाइम (E2B, Modal, Daytona, Cloudflare) तेज़ हैं, लेकिन आपके एजेंटों का कोड, डेटा और क्रेडेंशियल किसी और के इन्फ्रास्ट्रक्चर पर चलते हैं, जिसमें समतुल्य क्षमता पर कोई सेल्फ-होस्ट पथ नहीं है। Morph ने सही स्टेट मॉडल (branch/restore) एक प्रोप्राइटरी क्लाउड के रूप में बनाया; हमारा Workspace प्राइमिटिव उसी सेमेन्टिक्स को लक्षित करता है, ओपन सोर्स, fork(2) गति पर। Agent Sandbox (k8s-sigs) बिना स्नैपशॉट-फोर्क इंजन के Kubernetes API मानक जीत रहा है, यही कारण है कि हम उससे लड़ने के बजाय उसका सबसे तेज़ बैकएंड बनने के लिए एक कंफर्मेंस फेसडे (`cmd/facade`) भेजते हैं ([docs/facade-conformance.md](https://github.com/mitos-run/mitos/blob/HEAD/docs/facade-conformance.md))। Kata, KubeVirt और raw Firecracker आपको अलगाव प्राइमिटिव देते हैं और पूल, फोर्क, वितरण और एजेंट-API परतों को आपकी समस्या के रूप में छोड़ देते हैं।

यदि कोई विकल्प आपके लिए महत्वपूर्ण किसी धुरी पर हमें हरा देता है और हमारे पास उसे बंद करने वाली कोई रोडमैप लाइन नहीं है, तो यह हमारी रणनीति में एक बग है: एक इश्यू खोलें।

## आर्किटेक्चर

Mitos Firecracker microVM बूट करता है, उन्हें कॉपी-ऑन-राइट स्नैपशॉट के माध्यम से फोर्क करता है, और पूरे जीवनचक्र को `mitos.run/v1` API समूह में डिक्लेरेटिव CRDs (`SandboxPool`, `Sandbox`, `Workspace`) के माध्यम से उजागर करता है। एक सैंडबॉक्स एक microVM है, पॉड नहीं: इसे KVM के माध्यम से हार्डवेयर अलगाव मिलता है, और पॉड-स्कोप्ड तंत्र (NetworkPolicy, ResourceQuota, PSA) इसे नियंत्रित नहीं करते हैं।

घटक:

- **controller** (Deployment): CRDs को रिकंसिल करता है, एक नोड चुनता है, और `forkd` को चलाता है। यह प्रति-नोड क्षमता हार्टबीट द्वारा पोषित रजिस्ट्री के माध्यम से उपलब्ध फोर्क नोड्स को ट्रैक करता है।
- **forkd** (DaemonSet): VMs का स्वामित्व रखने वाला प्रति-नोड डेमन। यह कंट्रोलर के लिए `:9090` पर gRPC (fork, prepare-pool, heartbeat) और exec और फ़ाइल ट्रैफ़िक के लिए `:9091` पर HTTP सैंडबॉक्स API प्रदान करता है। इसे `/dev/kvm` चाहिए, इसलिए यह केवल KVM-सक्षम नोड्स पर चलता है।
- **guest agent**: प्रत्येक microVM के अंदर PID 1। यह exec, फ़ाइलों, वातावरण और फोर्क सूचनाओं के लिए vsock प्रोटोकॉल बोलता है।
- **sandbox-server**: एक सादे REST API के पीछे वही फोर्क इंजन, बिना Kubernetes की आवश्यकता के, स्थानीय लूप और एकल-होस्ट उपयोग के लिए।
- **SDKs** (`sdk/python`, `sdk/typescript`, `sdk/go`, और अधिक): होस्टेड सेवा, क्लस्टर या `sandbox-server` के लिए क्लाइंट।

दो हॉट पाथ सिस्टम को संचालित करते हैं:

- **क्लेम पथ**: कंट्रोलर रजिस्ट्री से एक वार्म नोड चुनता है और gRPC के ऊपर `forkd` `Fork` को कॉल करता है; परिणामी सैंडबॉक्स उस नोड पर `forkd` के HTTP API के माध्यम से Ready रिपोर्ट करता है।
- **Exec पथ**: SDK या CLI `:9091` पर `forkd` से बात करता है, जो VM के अंदर guest agent तक vsock के ऊपर ब्रिज करता है।

फोर्क मुख्य प्राइमिटिव है: एक स्रोत VM एक बार स्नैपशॉट किया जाता है और N चाइल्ड कॉपी-ऑन-राइट के माध्यम से उस स्नैपशॉट से रिस्टोर होते हैं, इसलिए प्रत्येक सहोदर वार्म और स्वतंत्र रूप से उतरता है जबकि साझा टेम्पलेट पेज एक बार संग्रहीत और मीटर किए जाते हैं। क्योंकि Firecracker को हार्डवेयर वर्चुअलाइजेशन की आवश्यकता होती है, बेयर मेटल (Hetzner पर Talos संदर्भ प्लेटफ़ॉर्म है) एक प्रथम-श्रेणी लक्ष्य है; क्लाउड कंट्रोल प्लेन सामान्य नोड्स पर रहता है जबकि निष्पादन KVM-सक्षम मशीनों पर उतरता है।

## परियोजना स्थिति

प्रारंभिक विकास, pre-1.0 (नवीनतम रिलीज़ `v0.3.0`)। अभी प्रोडक्शन में अविश्वसनीय कोड न चलाएँ: कोई बाहरी सुरक्षा समीक्षा नहीं हुई है और कुछ अलगाव नियंत्रण खुले हैं (सटीक प्रति-सीमा स्थिति के लिए [थ्रेट मॉडल](https://mitos.run/docs/threat-model) देखें)। कंट्रोल प्लेन एंड-टू-एंड वास्तविक है, जो मॉक इंजन और वास्तविक Firecracker VMs के विरुद्ध CI में सिद्ध है, और एकल-नोड Talos KVM क्लस्टर पर अभ्यास किया गया है।

**वास्तविक KVM क्लस्टर पर सत्यापित (husk डिफ़ॉल्ट):** वार्म-क्लेम एक्टिवेट, ब्लॉकिंग exec, `KernelUnavailable` के साथ फेल-क्लोज्ड `run_code`, सेल्फ-हील / री-पेंड, पूल वार्मिंग के साथ माँग ऑटोस्केलिंग, लाइव सैंडबॉक्स फोर्क (स्रोत husk पॉड अपने VM को स्नैपशॉट करता है और N चाइल्ड पॉड इसे CoW के माध्यम से रिस्टोर करते हैं, प्रत्येक एक स्वतंत्र Ready चाइल्ड), टिकाऊ फोर्केबल वर्कस्पेस (create -> commit -> fork), और पॉड ईग्रेस अलगाव (डिफ़ॉल्ट-अस्वीकार, क्लाउड-मेटाडेटा ब्लॉक, प्रति-टेम्पलेट अनुमतिसूची)।

**husk डिफ़ॉल्ट पर अभी तक नहीं आए ट्रैक किए गए टेल:** स्ट्रीमिंग exec और इंटरैक्टिव PTY; रिज़्यूमेबल वर्कस्पेस हेड्स के लिए लाइव-VM मेमोरी स्नैपशॉट हुक; S3/एन्क्रिप्शन लाइव स्टोर-चयन; husk `{git}` वर्कस्पेस पुश; और मल्टी-नोड N>1 (डिज़ाइन किया गया, एकल-नोड-सत्यापित)।

[ROADMAP.md](https://github.com/mitos-run/mitos/blob/HEAD/ROADMAP.md) इस बात का एकमात्र स्रोत है कि क्या पूरा हुआ है, प्रगति पर है, और गेटेड है। परिचालन नियम: यह रिपॉजिटरी कभी भी ऐसी प्रणाली का वर्णन नहीं करती जो मौजूद नहीं है।

## स्थानीय विकास (KVM आवश्यक नहीं)

`mitos dev up` एक मॉक कंट्रोल प्लेन पर एक स्थानीय kind क्लस्टर लाता है और `mitos` CLI पूरे क्लेम पथ को चलाता है; मॉक इंजन क्लेम को `Ready` में रिकंसिल करता है और कंट्रोल-प्लेन डिस्पैच का अभ्यास करता है, लेकिन वास्तविक इन-VM `exec` के लिए `/dev/kvm` वाले नोड की आवश्यकता होती है। बिना-क्लस्टर REST लूप के लिए, `go run ./cmd/sandbox-server --mock --addr :8080` चलाएँ और Python SDK को उसकी ओर इंगित करें। पूरा kind वॉकथ्रू [mitos.run/docs/cli](https://mitos.run/docs/cli) पर है।

## दस्तावेज़ीकरण

पूर्ण दस्तावेज़ीकरण **[mitos.run/docs](https://mitos.run/docs)** पर रहता है: क्विकस्टार्ट, आर्किटेक्चर, SDK और CLI संदर्भ, सैंडबॉक्स जीवनचक्र, वर्कस्पेस, नेटवर्किंग और थ्रेट मॉडल, सभी इस रिपॉजिटरी से रेंडर किए गए।

पूर्ण लॉन्ग टेल (टेम्पलेट, स्नैपशॉट प्रारूप और वितरण, एन्क्रिप्शन और गोपनीय डेटा, शेड्यूलिंग और घनत्व, विफलता और GC, फोर्क-इंजन शुद्धता, रेसिपी और लक्षित v2 API स्पेक) इस रिपॉजिटरी में [`docs/`](https://github.com/mitos-run/mitos/blob/HEAD/docs/) में रहती है। बेंचमार्क पद्धति [BENCHMARKS.md](https://github.com/mitos-run/mitos/blob/HEAD/BENCHMARKS.md) में है।

## योगदान

योगदान का स्वागत है। परंपराओं के लिए [CONTRIBUTING.md](https://github.com/mitos-run/mitos/blob/HEAD/CONTRIBUTING.md) और [CLAUDE.md](https://github.com/mitos-run/mitos/blob/HEAD/CLAUDE.md) देखें, और [ROADMAP.md](https://github.com/mitos-run/mitos/blob/HEAD/ROADMAP.md) के विरुद्ध ट्रैक किए गए कार्य के लिए [इश्यू पेज](https://github.com/mitos-run/mitos/issues) देखें।

## सुरक्षा

प्रति-सीमा स्थिति वाला थ्रेट मॉडल [mitos.run/docs/threat-model](https://mitos.run/docs/threat-model) पर रहता है; अभी तक कोई बाहरी सुरक्षा समीक्षा नहीं हुई है, और दस्तावेज़ ठीक वही कहता है जो खुला है। कमजोरी की रिपोर्ट करने के लिए, [SECURITY.md](https://github.com/mitos-run/mitos/blob/HEAD/SECURITY.md) देखें।

## लाइसेंस

[Apache 2.0](https://github.com/mitos-run/mitos/blob/HEAD/LICENSE)।

fork -> first exec	P50 ~104 ms (रेफरेंस नोड), reflink + NVMe पर ~67 ms	एक लाइव फोर्क से एक तैयार, exec-सेवा देने वाले चाइल्ड तक
fork(n) fan-out	n=4 और n=16 पर ~56 ms P50 प्रति चाइल्ड	एक वार्म बेस N स्वतंत्र सिबलिंग्स में फैन किया गया
CoW मेमोरी डेंसिटी	8 फोर्क्स की लागत ~35 MiB रेसिडेंट, ~209 MiB नहीं	यूनीक पेजों के लिए भुगतान, साझा पेज एक बार गिने जाते हैं
go build -o /tmp/bench ./cmd/bench/
/tmp/bench --mode fork-exec --template --data-dir --iterations 100 # fork -> first exec
/tmp/bench --mode fork-fanout --template --data-dir --fanout-n 1,4,16 # 1-to-N fan-out

mitos

सबसे लोकप्रिय