Omnigent: అనేక agent CLIలకు ఒకే meta-harness

Omnigent అంటే ఏమిటి

Omnigent ఒక open source meta-harness. మీరు ఇప్పటికే install చేసిన agent command line tools (CLIs) ను నడిపించే ఒక orchestration layer ఇది. ఇది Claude Code, Codex, Cursor, OpenCode, Hermes లేదా Pi లను భర్తీ చేయదు. ఇది వాటిని ప్రారంభించి, ప్రతి దానికి ఒక పని అప్పగించి, ఒకే policy set తో ఒకే session లో ఫలితాన్ని పర్యవేక్షిస్తుంది. Databricks ఈ repository ని June 2026 లో Apache 2.0 licence కింద ప్రచురించింది. Front page లో ఇప్పటికీ Status: alpha అని ఉంది.

దీని ప్రాయోగిక ప్రయోజనం పరిమితమైనదే, కానీ స్పష్టంగా చెప్పాలి. మీరు ఒక agent ను YAML లో ఒక్కసారి వివరిస్తారు. దాన్ని నడిపించే harness పేరును పేర్కొంటారు. ఆ ఒక్క line ను మార్చితే, అదే agent వేరే vendor కు చెందిన CLI పై నడుస్తుంది. మీ setup లో మరేదీ మారదు. ఎందుకంటే Omnigent agents లోపలి loop కంటే agents పైన ఉన్న loop ను నిర్వహిస్తుంది.

మెటా-harness అంటే ఏమిటి? ఇది framework కంటే ఎలా భిన్నంగా ఉంటుంది?

harness అనేది model ను ఒక loop లో నడిపించే program. ఇది మీ prompt ను చదివి, tools ను call చేసి, files ను edit చేసి, ఫలితాన్ని తిరిగి అందిస్తుంది. Claude Code ఒక harness. Codex కూడా ఒక harness. మీరు దాన్ని install చేసి, login చేస్తే, అది స్వయంగా పని చేస్తుంది.

framework అనేది మీరు code రాయడానికి ఉపయోగించే library. మీరు దాన్ని import చేసి, Python లో steps నిర్వచిస్తారు. అప్పుడు మీ program agent గా మారుతుంది. అక్కడ vendor ను మార్చాలంటే మీ code ను edit చేయాలి, ఎందుకంటే vendor యొక్క client మీ program ద్వారా అనుసంధానించబడి ఉంటుంది.

meta-harness ఈ రెండింటికంటే ఒక స్థాయి పైగా పనిచేస్తుంది. ఇది harnesses ను child processes గా నడిపించే supervisor. Omnigent vendor CLI ను ప్రారంభించి, దానికి పని అప్పగించి, తిరిగి వచ్చే ఫలితాన్ని చదువుతుంది. మీరు ఇప్పటికే install చేసిన CLI నే కొనసాగించవచ్చు. దాని కోసం ఇప్పటికే ఉపయోగిస్తున్న subscription లేదా API (application programming interface) key ను కూడా కొనసాగించవచ్చు. మొత్తం తేడా ఇదే. ఈ సాధనం ఎవరికి ఉపయోగపడుతుందో కూడా ఇదే నిర్ణయిస్తుంది: ఇప్పటికే అనేక agent CLIs పనిచేస్తున్న, వాటిని ఒక్కో terminal లో విడిగా నడపడం వల్ల ఇబ్బంది పడుతున్న వారికి.

ఒక orchestration layer ఏ సమస్యను పరిష్కరిస్తుంది?

• Vendor మార్చడానికి ఒకే లైన్ మార్పు చాలు. Agent definition లో harness మరియు model data గా ఉంటాయి. అందువల్ల ఒక role ను ఒక vendor నుంచి మరొక vendor కు మార్చడం అంటే YAML file లో edit చేయడమే; మొత్తం configuration ను మళ్లీ రాయాల్సిన అవసరం లేదు.
• Review vendors మధ్య జరగవచ్చు. ఒక model రాసిన diff ను వేరే company కి చెందిన model చదవగలదు. ఒకే family కి చెందిన రెండు models సాధారణంగా ఒకే blind spots కలిగి ఉంటాయి. అందువల్ల అదే vendor నుంచి వచ్చిన second opinion విలువ తక్కువగా ఉంటుంది.
• Policy కి ఒకే కేంద్ర స్థానం ఉంటుంది. Spend caps మరియు approval prompts agent file లో declare చేస్తారు. అవి దాని కింద ఉన్న ప్రతి sub-agent కు వర్తిస్తాయి.
• Session ఏ ఒక్క tool కంటే ఎక్కువకాలం కొనసాగుతుంది. అనేక CLIs చేసిన పనిని ఒకే transcript నమోదు చేస్తుంది. అందువల్ల నాలుగు scrollbacks ను కలపకుండానే ఏమి జరిగిందో తిరిగి చదవవచ్చు.

దీనికి అయ్యే ఖర్చు ఆ layer స్వయమే. Omnigent లోని ప్రతి bug ఇప్పుడు మీకు మరియు ఇంతకుముందు స్వతంత్రంగా పనిచేసిన agent కు మధ్య ఉన్న bug అవుతుంది. Alpha దశలో ఇది వాస్తవమైన ఖర్చు; కేవలం సిద్ధాంతపరమైనది కాదు.

ఒకే agent సాధనాల పక్కన multi-agent harness ఎక్కడ సరిపోతుంది

మీరు ఇంకా serverలో ఒక agentను నడపకపోతే, ముందుగా అక్కడి నుంచే ప్రారంభించండి. VPSపై coding agentను నడపడం పై మా guide ఒకే agent వినియోగాన్ని ప్రారంభం నుంచి ముగింపు వరకు వివరిస్తుంది. Omnigent మీరు ఈ setup ఇప్పటికే కలిగి ఉన్నారని భావిస్తుంది. self-hosted AI agents‌కు సంబంధించిన విస్తృత రంగంలో మీరు agentsను ఎంచుకుంటారు. ఇక్కడి పదజాలం కొత్తగా ఉంటే, agents వాస్తవంగా ఎలా పనిచేస్తాయో నేర్చుకోవడం‌తో ప్రారంభించడం మంచిది.

Omnigent connector layerకు భిన్నమైన అంశం. agentsకు మీ స్వంత data sourcesకు access ఇవ్వడం వంటి పని agent ఏ వనరులను చేరుకోగలదో నిర్ణయిస్తుంది. Omnigent ఏ agent నడవాలి, ఏ క్రమంలో నడవాలి, ఎలాంటి పరిమితులలో నడవాలి అనే విషయాలను నిర్వహిస్తుంది. మీరు రెండింటినీ ఒకేసారి ఉపయోగించవచ్చు. అవి ఒకదానితో మరొకటి overlap కావు.

మీరు ఇన్‌స్టాల్ చేయడానికి ముందు అవసరమైనవి

• Python 3.12 లేదా ఆ తర్వాతి వెర్షన్. ప్రచురించిన package requires-python >= 3.12 ను ప్రకటిస్తుంది.
• tmux, ఎందుకంటే terminal harnesses అందులోనే నడుస్తాయి.
• కనీసం ఒక vendor CLI ముందుగానే ఇన్‌స్టాల్ చేసి, దానిలో ఇప్పటికే login అయి ఉండాలి.
• git checkout నుంచి build చేస్తే మాత్రమే Node.js 22 అవసరం. PyPIలోని wheel ఇప్పటికే నిర్మించిన web assets ను కలిగి ఉంటుంది. అందువల్ల సాధారణ install కు Node అసలు అవసరం లేదు.

స్థిరపరచిన release ను install చేయండి, main ను కాదు

curl -fsSL https://raw.githubusercontent.com/omnigent-ai/omnigent/main/scripts/install_oss.sh | sh -s -- --version 0.7.0

sh -s -- భాగం అలంకారం కాదు. అది లేకపోతే sh, --version ను తన స్వంత option గా పరిగణిస్తుంది. Installer కు ఆ flag కనిపించదు. అందువల్ల ఆ రోజున అందుబాటులో ఉన్న అత్యంత కొత్త release install అవుతుంది. ప్రతి కొన్ని వారాలకు breaking changes విడుదల చేసే repository లో, ఇది పునరుత్పత్తి చేయగల సర్వర్‌కి మరియు ఊహించని మార్పులకు మధ్య ఉన్న తేడా.

Installer, Astral యొక్క Python package manager అయిన uv ను ఉపయోగిస్తుంది. uv లేకపోతే ముందుగా దాన్ని install చేయమని అడుగుతుంది. uv ఇప్పటికే ఉంటే script ను దాటవేయండి:

uv tool install --force --python 3.12 "omnigent==0.7.0"

Extras కూడా ఇదే విధానాన్ని అనుసరిస్తాయి. Flag కూడా మళ్లీ ఇవ్వాలి: script లో --extra e2b --extra kubernetes లేదా uv తో "omnigent[e2b,kubernetes]". git tag v0.7.0 కాగా, PyPI లో package version 0.7.0 అని గమనించండి.

uv binary ను uv tool dir --bin చూపించే directory లో ఉంచుతుంది. సాధారణంగా అది ~/.local/bin. దీన్ని మీ shell profile కు జోడించమని installer సూచిస్తుంది. Clean install చేసిన వెంటనే command కనబడకపోతే కారణం ఇదే. చివరికి ఏమి install అయిందో తనిఖీ చేయండి:

omni upgrade --check

ఇది install చేసిన version ను తాజాగా ప్రచురించిన version తో పోల్చుతుంది. Upgrade అందుబాటులో ఉందో తెలియజేస్తుంది, కానీ upgrade చేయదు. omni మరియు omnigent ఒకే program కు ఉన్న రెండు పేర్లు.

మోడల్ provider కు దాన్ని సూచించండి

omni setup

Wizard మీ environment లో ఇప్పటికే ఉన్న credentials ను గుర్తించి, లేని credentials కోసం అడుగుతుంది. ఇది API keys, vendor subscriptions, OpenRouter లేదా Ollama వంటి gateways, అలాగే Databricks workspaces ను నిర్వహిస్తుంది. అదే machine పై ఇప్పటికే Ollama తో local model server నడుపుతున్నట్లయితే, gateway ను దానికి సూచించండి; అప్పుడు network traffic ఆ machine ను దాటి బయటకు వెళ్లదు.

కనిష్ట multi-agent అమలు

ఉదాహరణ agents repositoryలో ఉన్నాయి. అందువల్ల main కాకుండా, మీరు install చేసిన అదే tagను clone చేయండి.

git clone --depth 1 --branch v0.7.0 https://github.com/omnigent-ai/omnigent.git
cd omnigent
omnigent run examples/polly/

Polly అనేది repositoryతో పాటు వచ్చే multi-agent coding orchestrator. దీని configలో claude_code, codex, opencode, cursor, hermes మరియు pi పేర్లతో sub-agents ప్రకటించబడ్డాయి. ఈ మొత్తం ప్రక్రియను అమలు చేయడానికి ప్రధాన కారణం ఒక నియమం: implementerకు భిన్నమైన vendor ఎల్లప్పుడూ review చేయాలి. Polly స్వయంగా code రాయదు. ఇది లక్ష్యాన్ని ప్రణాళిక చేస్తుంది, దాన్ని work itemsగా విభజిస్తుంది, ప్రతి itemను ఒక agentకు అప్పగిస్తుంది, ఆపై ప్రతి diffను వేరే vendorకు చెందిన reviewerకి పంపుతుంది.

ఏదైనా పని అప్పగించే ముందు, ఏ sub-agent CLIs machineలో నిజంగా ఉన్నాయో తెలుసుకోవడానికి Polly preflight checkను అమలు చేస్తుంది. ఒక vendor CLI మాత్రమే install చేసి ఉంటే diffను అప్పగించడానికి మరొకరు ఉండరు. కాబట్టి outputను అంచనా వేయడానికి ముందు కనీసం రెండు install చేయండి. Debby అనేది repositoryతో పాటు వచ్చే మరో ఉదాహరణ. ఇది రెండు heads కలిగిన debate agent: ఒకటి Claude, మరొకటి GPT.

omni debby

రెండు providers configure అయ్యాయో లేదో నిర్ధారించడానికి ఇది సంక్షిప్త మార్గం. ఏదైనా output ఇవ్వాలంటే దీనికి రెండూ అవసరం.

సబ్-ఏజెంట్లు tools గా ప్రకటించబడతాయి

ఏజెంట్ ఫైల్ YAML లో ఉంటుంది. executor harness, model మరియు authentication పేర్లను నిర్వచిస్తుంది. tools లో MCP (model context protocol) servers, Python functions మరియు sub-agents ఉంటాయి. సబ్-ఏజెంట్ అనేది type: agent కలిగిన tool. దానికి స్వంత executor కూడా ఉంటుంది. పైవన్నింటి వెనుక పనిచేసే విధానం ఇదే.

name: orchestrator
prompt: |
  You coordinate coding and review tasks.

executor:
  harness: claude-sdk
  model: databricks-claude-sonnet-4-6

tools:
  coder:
    type: agent
    prompt: Write and test code.
    executor:
      harness: claude-sdk
      model: databricks-claude-opus-4-7
  reviewer:
    type: agent
    prompt: Review proposed changes.
    executor:
      harness: claude-sdk
      model: databricks-claude-sonnet-4-6

omnigent run path/to/my_agent.yaml

ఆ model ids ప్రాజెక్ట్‌కు చెందిన docs/AGENT_YAML_SPEC.md example నుంచి వస్తాయి. అవి Databricks-hosted పేర్లు. మీ సిస్టమ్‌లో omni setup configure చేసిన విలువలతో harness మరియు model ను భర్తీ చేయండి. Generic protocol ఉపయోగించే వాటికి spec లోని ఇతర harness విలువలు antigravity, copilot, kimi, qwen మరియు acp:<slug>. సబ్-ఏజెంట్‌పై pass_history: true ను కూడా spec support చేస్తుంది. ఇది parent conversation ను సబ్-ఏజెంట్‌కు పంపుతుంది. ప్రతి delegation సమయంలో దీనికి tokens ఖర్చవుతాయి. అందువల్ల ముందున్న task మాత్రమే అవసరమైన సబ్-ఏజెంట్లలో దీనిని enable చేయకుండా ఉంచండి. ఒక coder యొక్క prompt, పనిచేసే అతి చిన్న మార్పు చేయాలని దానికి చెబితే, అది reviewer కు నిజంగా చదవగలిగేంత చిన్న diff ను పంపుతుంది. ఇక్కడ రెండు పాత్రలకు మీరు ఎంచుకునే model కంటే ఈ విషయం ముఖ్యమైనది.

దీర్ఘకాలం నడిచే orchestration ను VPS పై ఎందుకు నిర్వహించాలి

Multi-agent run అనేది రెండు నిమిషాల command కాదు. ప్రణాళిక రూపొందించాలి, పనులను అప్పగించాలి, parallel git worktrees పూర్తయ్యే వరకు వేచి ఉండాలి, review చేయాలి, మళ్లీ సవరించాలి. Laptop lid మూసివేస్తే ఇవన్నీ ఆగిపోతాయి. VPS (virtual private server) నిరంతరం నడుస్తూ network connection ను కొనసాగిస్తుంది. అందువల్ల మీరు గమనించనప్పుడు కూడా session కొనసాగుతుంది.

omnigent server --background
omnigent server status

Server, port 6767 పై web user interface ను అందిస్తుంది. omnigent server status ద్వారా ఒక session నడుస్తుందో లేదో తెలుసుకోవచ్చు. omnigent stop దాన్ని ఆపుతుంది. v0.7.0 కు ముందు విడుదలల్లో ఇది omni server start గా ఉండేది. అది తొలగించబడింది. అందువల్ల పాత write-ups మరియు screenshots మీ terminal లో కనిపించే ఫలితాలతో సరిపోలవు.

6767 ను public address పై publish చేయవద్దు. సురక్షితమైన రెండు విధానాలు ఉన్నాయి. Firewall వద్ద port ను మూసి ఉంచి, ssh -N -L 6767:localhost:6767 you@your-server తో SSH ద్వారా forward చేయండి. తరువాత మీ స్వంత machine లో http://localhost:6767 వద్ద web interface ను తెరవండి. లేదా దాని ముందు TLS (transport layer security) termination అమలు చేసి authentication ను ప్రారంభించండి:

OMNIGENT_AUTH_ENABLED=1 omnigent server --background

దీనిలోని firewall భాగం సాధారణ నిర్వహణ పనిలో భాగమే. ఇది VPS కోసం ufw firewall ప్రాథమికాలు లో వివరించబడింది. ఆ server ఇప్పటికే అనేక Docker Compose apps ముందు Traefik ను ఉపయోగించి containers ను నడుపుతుంటే, Omnigent కూడా అదే విధానంలోని మరో service అవుతుంది.

Container deploy కోసం repository లోని deploy/ directory లో Compose setup ఉంటుంది. ./bootstrap.sh secrets ను .env లోకి సృష్టిస్తుంది. తరువాత docker compose up -d Omnigent మరియు Postgres ను port 6767 పై ప్రారంభిస్తుంది. DATABASE_URL Postgres లేదా SQLite ను ఎంచుకుంటుంది. Containers లో OMNIGENT_AUTH_ENABLED కు default విలువ 1. బయట నుంచి చేరుకోగల ఏ deployment కైనా ఇదే సరైన default.

Sizing విషయానికి వస్తే, deploy notes ప్రకారం server యొక్క working set సుమారు 512 MB నుంచి 1 GB వరకు ఉంటుంది. Fly.io config 1 GB ను నిర్దేశిస్తుంది. ఈ పరిమాణం supervisor కు మాత్రమే సంబంధించినది. ప్రతి sub-agent ఒక ప్రత్యేక process. అది తన స్వంత checkout మరియు తన స్వంత model client ను కలిగి ఉంటుంది. అందువల్ల agents కోసం server పరిమాణాన్ని నిర్ణయించాలి. Server ప్రారంభమైన తరువాత omnigent login https://your-host ను అమలు చేసి, దాని తరువాత omnigent host https://your-host ను అమలు చేస్తే మీ laptop ను ఆ server తో register చేయవచ్చు. omnigent attach <session_id> ద్వారా మరో device నుంచి నడుస్తున్న session ను మళ్లీ కొనసాగించవచ్చు.

ప్రయాణం ముగించే ముందు ప్రతి sub-agent ను sandbox లో పరిమితం చేయండి

Omnigent, Omnibox అనే operating system స్థాయి sandbox ను అందిస్తుంది. Linuxలో ఇది bubblewrap namespaces మరియు seccomp ను ఉపయోగిస్తుంది. అందువల్ల పరిమితిని agent prompt కాకుండా kernel అమలు చేస్తుంది. Prompt injection కు గురైన agent kernel నియమాన్ని తప్పించుకోలేడు. ముందుగా dependency ను install చేయండి:

sudo apt install bubblewrap

Configuration agent file లోని os_env కింద ఉంటుంది:

os_env:
  type: caller_process
  cwd: .
  sandbox:
    type: linux_bwrap
    write_paths: [.]
    write_files: []
    read_paths: []
    allow_network: true
    cwd_allow_hidden: [.venv]
    env_passthrough: []
    egress_rules: []
    credential_proxy: []

మీరు దాన్ని write_paths లో జాబితా చేసే వరకు working directory read-onlyగా ఉంటుంది. అందువల్ల తప్పుగా పనిచేసే agent workspace వెలుపల రాయలేడు. cwd_allow_hidden లో పేరుతో పేర్కొనకపోతే dotfiles కనిపించవు. దీని వల్ల విస్తృత read అనుమతి .ssh లేదా .aws ను నిశ్శబ్దంగా బహిర్గతం చేయదు. egress_rules ను సెట్ చేస్తే HTTP మరియు HTTPS traffic అంతా default deny proxy ద్వారా వెళ్తుంది. ప్రతి నియమాన్ని "METHODS host/path-glob" రూపంలో రాయాలి. credential_proxy దీనికంటే మరింత కఠినంగా పనిచేస్తుంది. Agent వద్ద ఎప్పుడూ placeholder మాత్రమే ఉంటుంది. Request బయటకు వెళ్లే సమయంలో proxy నిజమైన secret ను భర్తీ చేస్తుంది. అందువల్ల transcript బయటపడినా ఉపయోగించగల secret బయటపడదు. Multi-harness setup లో ప్రతి sub-agent తన సొంత config file లోని agents/ కింద తన సొంత sandbox block ను కలిగి ఉంటుంది. అందువల్ల reviewer కు network ను నిరాకరించవచ్చు, implementer కు network అందుబాటులో ఉంచవచ్చు.

ఈ పరిమితి documentation లో స్పష్టంగా ఉంది. ఇది ముఖ్యమైన విషయం. OS sandbox sys_os_* tool calls మరియు terminals కు వర్తిస్తుంది. MCP servers కు ఇది వర్తించదు. Omnigent supervisor process కు కూడా ఇది వర్తించదు. మీరు ప్రారంభించిన MCP server మీ permissions తో sandbox వెలుపల నడుస్తుంది. అందుకే మరింత బలమైన విధానం ఇప్పటికీ ప్రతి agent కోసం ఒక throwaway machine ఉపయోగించడం. దీని గురించి disposable VM లో coding agents ను నడపడం లో వివరించాం. మరో ముఖ్యమైన భాగం credentials నిర్వహణ. ఆరు sub-agents ఒకే host ను పంచుకున్నప్పుడు agent అందుబాటులో secrets లేకుండా ఉంచడం మరింత కష్టమవుతుంది.

Spend limits అనేవి policies. వీటిని అదే file లో ప్రకటించాలి:

policies:
  budget:
    type: function
    handler: omnigent.policies.builtins.cost.cost_budget
    factory_params:
      max_cost_usd: 5.00
      ask_thresholds_usd: [1.00, 3.00]

ఒక run మొదటి vendor తో planning చేసి, రెండవ vendor తో implementation చేసి, మూడవ vendor తో review చేస్తే ఒకేసారి మూడు చోట్ల ఖర్చు జరుగుతుంది. అందువల్ల మొదటి unattended run కు ముందే cap ను సెట్ చేయండి. మొదటి invoice వచ్చిన తర్వాత సెట్ చేయకండి. Built-ins లో max_tool_calls_per_session మరియు ask_on_os_tools కూడా ఉన్నాయి. ఇవి file మరియు shell operations కు ముందు approval అడుగుతాయి. VPS పై AI agent ఖర్చులను నియంత్రించడం పై మా గమనికలు ఇక్కడ నేరుగా వర్తిస్తాయి. Parallel sub-agents burn rate ను గుణిస్తాయి కాబట్టి ఇక్కడ అవి మరింత ముఖ్యమైనవి.

ఈ repository ఎంత వేగంగా మారుతోంది?

[
  {
    "version": "v0.2.0",
    "released": "2026-06-19",
    "interval": 3
  },
  {
    "version": "v0.3.0",
    "released": "2026-06-27",
    "interval": 8
  },
  {
    "version": "v0.4.0",
    "released": "2026-07-03",
    "interval": 6
  },
  {
    "version": "v0.5.0",
    "released": "2026-07-10",
    "interval": 7
  },
  {
    "version": "v0.5.1",
    "released": "2026-07-10",
    "interval": 0
  },
  {
    "version": "v0.6.0",
    "released": "2026-07-21",
    "interval": 11
  },
  {
    "version": "v0.7.0",
    "released": "2026-07-27",
    "interval": 6
  }
]

ఇవి 3 August 2026న ప్రాజెక్ట్‌కు చెందిన releases pageలో కనిపించిన విడుదల తేదీలు. 2026-06-19 మరియు 2026-07-27 మధ్య 7 tagged releases వచ్చాయి. ఏ రెండు విడుదలల మధ్యలోనైనా ఉన్న అత్యధిక విరామం 11 రోజులు. v0.5.1 దాని ముందు వచ్చిన release వచ్చిన రోజునే విడుదలైంది. మొదటి release అయిన 0.1.1ను, దాన్ని కొలవడానికి ముందు tag ఏదీ లేనందున chartలో చేర్చలేదు.

ఆ releasesలో రెండు guidesలో ఇప్పటికే document చేసిన commandsను మార్చాయి. v0.7.0లో omni server start తొలగించి దాని స్థానంలో omni server --backgroundను ఉపయోగించారు. v0.6.0లో omnigent[memory] extra పేరును omnigent[hindsight]గా మార్చారు. అందువల్ల Juneలో రాసిన write-up నుంచి copy చేసిన install line July buildలో విఫలమవుతుంది. మీ install commandలో --versionను, మీ git cloneలో tagను ఉపయోగించడానికి ఇదే కారణం; ఇది కేవలం style preference కాదు.

ఇప్పటికీ దీనికి నేను అప్పగించని పనులు

August 2026 నాటికి ఈ repositoryకి సుమారు 8.1k stars, 1.2k forks మరియు దాదాపు 350 open issues ఉన్నాయి. మొదటి public release వచ్చి ఏడు వారాలే అయింది. Stars ఆసక్తిని సూచిస్తాయి; ఆసక్తి maturityకి సమానం కాదు. Project స్వయంగా alpha అని చెబుతోంది. పై release history కూడా అది నిజంగా alpha స్థాయిలోనే ఉందని చూపుతోంది.

• Production credentials ఉన్న hostపై దీన్ని అమలు చేయను, ఎందుకంటే sandbox MCP servers లేదా supervisorను కవర్ చేయదు.
• cost_budget policy లేకుండా runను unattendedగా వదలను, ఎందుకంటే మూడు vendors సమాంతరంగా charge చేయవచ్చు; వాటిని ఆపే మరే నియంత్రణ లేదు.
• OMNIGENT_AUTH_ENABLED సెట్ చేయకుండా, దాని ముందు TLS లేకుండా, serverను public IP addressపై expose చేయను.
• Agent YAMLను minor versions మధ్య stableగా పరిగణించను. అందువల్ల versionను pin చేసి, upgrade చేయడానికి ముందు release notes చదవండి.

ఇది మిమ్మల్ని అనుకోకుండా ఆశ్చర్యపరచకముందు తెలుసుకోవాల్సిన మరో విషయం ఉంది: v0.6.0 anonymised usage telemetryను జోడించింది. Project దీన్ని ప్రత్యేక telemetry pageలో documentationగా అందిస్తుంది. ఆ machineపై client work జరుగుతుంటే, ఆ page చదివి ఉద్దేశపూర్వకంగా నిర్ణయం తీసుకోండి.

ఈరోజు Omnigent నిజంగా బాగా చేయగలిగేది, దాన్ని నిర్మించిన అసలు పనినే. మీ వద్ద మూడు లేదా నాలుగు agent CLIs ఉన్నాయి, వాటికి మీరు ఇప్పటికే చెల్లిస్తున్నారు, మరియు ఒకటి రాస్తుండగా మరొకటి review చేయాలని మీరు కోరుకుంటున్నారు. ఇది ఇప్పుడు ఒక machineపై, Linuxలో నిజమైన sandboxingతో పనిచేస్తుంది. దాని దాటి ఉన్న ప్రతిదాన్ని promising అయినా ఇంకా పూర్తికాని లక్షణంగా పరిగణించండి.

FAQ

Omnigent agentనా, లేదా agentలను నడిపించే వ్యవస్థనా?

ఇది agentలను నడుపుతుంది. Omnigent ఒక meta-harness: మీరు ఇప్పటికే install చేసిన Claude Code, Codex లేదా OpenCode వంటి vendor CLIలను ప్రారంభించి, ప్రతి దానికి పనిని కేటాయించి, ఒకే sessionలో ఫలితాలను పర్యవేక్షిస్తుంది. దీనికి స్వంత model ఉండదు. అందువల్ల ఇది frameworkకు భిన్నం. Frameworkలో మీరు libraryపై Python code రాస్తారు, ఆపై మీ స్వంత program agentగా మారుతుంది.

Omnigent ఉపయోగకరంగా ఉండాలంటే Claude Code మరియు Codex ముందే install చేసి ఉండాలా?

కనీసం ఒక vendor CLI install చేసి, దానిలో login అయి ఉండాలి. Omnigent ఆ programsను replace చేయకుండా వాటినే నియంత్రిస్తుంది. అందించిన Polly ఉదాహరణకు వేర్వేరు vendorsకు చెందిన రెండు లేదా అంతకంటే ఎక్కువ CLIలు అవసరం. Polly నియమం ప్రకారం reviewను implementerకు భిన్నమైన vendor ఎల్లప్పుడూ చేయాలి. కాబట్టి ఒకే CLI ఉంటే diffను పంపడానికి రెండవ vendor ఉండదు.

తాజా versionకు బదులుగా నిర్దిష్ట Omnigent versionను ఎలా install చేయాలి?

Install scriptకు --version ను sh -s -- తో pass చేయండి; ఉదాహరణకు sh -s -- --version 0.7.0. -s -- లేకపోతే ఆ flagను sh స్వయంగా తీసుకుంటుంది, కాబట్టి script తాజా releaseను install చేస్తుంది. uv ఇప్పటికే ఉంటే, uv tool install --force --python 3.12 "omnigent==0.7.0" అదే పని చేస్తుంది. Git tag v0.7.0, అయితే PyPI version string 0.7.0.

Agentలను unattendedగా నడపడానికి Omnibox sandbox సరిపోతుందా?

ఇది కవర్ చేసే అంశాలకు బలమైన isolation ఇస్తుంది, కవర్ చేయని అంశాలను స్పష్టంగా పేర్కొంటుంది. Linuxలో ఇది bubblewrapతో పాటు seccompను ఉపయోగిస్తుంది. అందువల్ల kernel file మరియు network పరిమితులను అమలు చేస్తుంది, agent వాటిని దాటవేయలేరు. ఇది sys_os_* tool calls మరియు terminalsకు వర్తిస్తుందని documentation చెబుతుంది. MCP servers లేదా Omnigent supervisor processకు ఇది వర్తించదు. కాబట్టి MCP server మీ సాధారణ permissionsతో నడుస్తుంది. Unattended పనికి ప్రతి agent కోసం ప్రత్యేకంగా ఉపయోగించి పారేయగల virtual machine ఇప్పటికీ బలమైన isolationను అందిస్తుంది.

VPSలో Omnigent serverకు ఎంత memory అవసరం?

Project deploy notes ప్రకారం server working set సుమారు 512 MB నుంచి 1 GB వరకు ఉంటుంది. Fly.io configuration 1 GBను నిర్ణయిస్తుంది. ఇది supervisor మరియు port 6767పై మాత్రమే పనిచేసే web interfaceకు సరిపోతుంది. ప్రతి sub-agent తన స్వంత working copy మరియు model clientతో ప్రత్యేక processగా నడుస్తుంది. Polly తరహా runs parallel git worktreesను ఉపయోగిస్తాయి. అందువల్ల server కోసం కాకుండా, ఒకేసారి నడపాలనుకునే agents సంఖ్య ఆధారంగా RAM మరియు disk పరిమాణాన్ని నిర్ణయించండి.