Linux VPS లో Agentlas OS ని ఎలా ఇన్‌స్టాల్ చేయాలి?

Agentlas OS అంటే ఏమిటి

Agentlas OS అనేది ఒక ఓపెన్ సోర్స్ ఏజెంట్ రన్‌టైమ్. ఇది స్పెషలిస్ట్ ఏజెంట్లను డిస్క్‌లో ప్యాకేజీలుగా భద్రపరుస్తుంది మరియు ప్రతి పని కోసం ఒక తాత్కాలిక ఆర్కెస్ట్రేటర్‌ను సిద్ధం చేస్తుంది. మీరు దీన్ని మీ Linux VPS లోని సొంత యూజర్ ఖాతాలో ఇన్‌స్టాల్ చేసుకోవడం ద్వారా self-host చేసుకోవచ్చు. ఇది ఒక సర్వీస్ కాదు. ఇందులో ఎటువంటి డెమోన్ (daemon), వినే పోర్ట్ (listening port), వెబ్ ఇంటర్‌ఫేస్ లేదా కంటైనర్ ఇమేజ్ రిపోజిటరీలో ఉండవు.

ఆ చివరి వాక్యం ఈ పేజీలోని మిగిలిన అన్ని అంశాలను నిర్ణయిస్తుంది. చాలా మల్టీ-ఏజెంట్ సిస్టమ్‌లు ఎప్పుడూ రన్ అవుతూ ఏజెంట్లను నియంత్రించే ఒక సూపర్వైజర్ ప్రాసెస్‌ను కలిగి ఉంటాయి. Agentlas దీనికి భిన్నంగా పనిచేస్తుంది: స్పెషలిస్ట్‌లు డిస్క్‌లో ఫైల్స్‌గా ఉంటాయి, మరియు ఒక పని జరుగుతున్నప్పుడు మాత్రమే ఆర్కెస్ట్రేటర్ ఉనికిలో ఉంటుంది. దీనివల్ల కలిగే ఆచరణాత్మక ప్రయోజనం ఏమిటంటే, ఖాళీగా ఉన్నప్పుడు ఈ హబ్ మీ మెమరీని కాకుండా, కేవలం డిస్క్ స్థలాన్ని మాత్రమే తీసుకుంటుంది.

ఈ ప్రాజెక్ట్ తన ఓపెన్ కోర్‌ను Hephaestus అని పిలుస్తుంది. కమాండ్‌లు, పాత్‌లు మరియు ఎన్విరాన్‌మెంట్ వేరియబుల్స్‌లో మీరు చూసే పేరు ఇదే. ఈ రిపోజిటరీ agentlas-ai/Agentlas-OS, ఇది Apache-2.0 లైసెన్స్‌తో లభిస్తుంది మరియు ప్రధానంగా Python లో వ్రాయబడింది.

ఈ ప్రాజెక్ట్ ఎంత కొత్తది, నిజాయితీగా చెప్పాలంటే

ఈ రిపోజిటరీ 4 June 2026న సృష్టించబడింది. 12 August 2026 నాటికి ఇది సుమారు పది వారాల వయస్సు కలిగి, దాదాపు 1,150 stars మరియు 112 forks ను పొందింది. మీరు నిజమైన పని కోసం ఉపయోగించే సాఫ్ట్‌వేర్‌కు ఇది చాలా తక్కువ సమయం.

ప్రాజెక్ట్ వయస్సు కంటే దాని release cadence (విడుదల వేగం) ముఖ్యం. Version v1.1.103 ను 8 August 2026న, మరియు v1.2.0 ను 12 August 2026న విడుదల చేశారు. 1.1 సిరీస్‌లో వందకు పైగా tagged releases ఉన్నాయి, కొన్ని రోజుల్లో ఒకటి కంటే ఎక్కువ విడుదలలు ఆటోమేషన్ ద్వారా జరిగాయి. ఇంత వేగంగా కదిలే ప్రాజెక్ట్, మంగళవారం నుండి గురువారం మధ్యలో తన పనితీరును మార్చుకోవచ్చు.

కాబట్టి release ను pin చేయండి. ఇన్‌స్టాలర్ దీని కోసం ఒక environment variable ను చదువుతుంది, మరియు కింద ఉన్న గైడ్ మొత్తం దీనినే ఉపయోగిస్తుంది. రోజుకు అనేకసార్లు విడుదలయ్యే ప్రాజెక్ట్‌ను pin చేయకుండా ఇన్‌స్టాల్ చేస్తే, ఆ సమయంలో main లో ఏది అందుబాటులో ఉంటే అది మీకు వస్తుంది.

VPSలో మీకు కావలసినవి

ఏదీ బ్యాక్‌గ్రౌండ్‌లో రన్ అవ్వదు కాబట్టి, అవసరాలు చాలా తక్కువగా ఉంటాయి.

• ఒక Linux VPS. Ubuntu 24.04 ఒక మంచి బేస్‌లైన్. ఇన్‌స్టాలర్ uname -s తో ఆపరేటింగ్ సిస్టమ్‌ను గుర్తిస్తుంది మరియు Linux కోసం non-macOS బ్రాంచ్‌ను తీసుకుంటుంది, కాబట్టి headless బాక్స్‌లకు మద్దతు ఉంటుంది.
• బాక్స్‌పై curl, tar మరియు git, అలాగే పనిచేసే Python ఇంటర్‌ప్రెటర్ ఉండాలి.
• raw.githubusercontent.com మరియు github.com కి అవుట్‌బౌండ్ HTTPS కనెక్టివిటీ ఉండాలి. ఇన్‌స్టాలర్ ఒక release archiveను డౌన్‌లోడ్ చేసి దాని SHA-256ను తనిఖీ చేస్తుంది, కాబట్టి అవుట్‌బౌండ్ కనెక్టివిటీ లేని బాక్స్‌లో దీన్ని ఇన్‌స్టాల్ చేయలేము.
• ఒక host harness, ఇది మోడల్‌తో నేరుగా మాట్లాడే కోడింగ్ ఏజెంట్. Claude Code, Codex, opencode, goose మరియు Hermes అన్నీ సపోర్టెడ్ అడాప్టర్లే.

మీకు root అనుమతులు అవసరం లేదు. ఇన్‌స్టాలర్ మీ home డైరెక్టరీకి మరియు ~/.local/bin కి మాత్రమే వ్రాస్తుంది, ఒక పాత్ వ్రాయడానికి వీలులేనప్పుడు అది ఆగిపోకుండా హెచ్చరిస్తుంది. మీరు ఇంకా బాక్స్‌ను ఎంచుకునే పనిలో ఉంటే, VPSలో కోడింగ్ ఏజెంట్‌ను రన్ చేయడం అనే గైడ్, దీనికి అవసరమైన బేస్ ఇమేజ్ మరియు యాక్సెస్ సెటప్ గురించి వివరిస్తుంది.

పిన్ చేసిన విడుదల (pinned release) ను ఇన్‌స్టాల్ చేయండి

అప్‌స్ట్రీమ్ README లో main నుండి వచ్చే స్క్రిప్ట్‌ను నేరుగా bash లోకి పైప్ (pipe) చేసే ఒకే ఒక లైన్ ఉంటుంది. ముందుగా దానిని డౌన్‌లోడ్ చేసి చదవండి. ఇది మీ షెల్ కాన్ఫిగరేషన్‌లో మరియు దానికి దొరికిన ప్రతి ఏజెంట్ హార్నెస్‌లో (agent harness) సమాచారాన్ని రాస్తుంది, కాబట్టి పది సెకన్లు కేటాయించి పరిశీలించడం మంచిది.

curl -fsSL -o install-all-runtimes.sh \
  https://raw.githubusercontent.com/agentlas-ai/Agentlas-OS/main/scripts/install-all-runtimes.sh
less install-all-runtimes.sh
HEPHAESTUS_REF=v1.2.0 bash install-all-runtimes.sh

HEPHAESTUS_REF అనేది పిన్ (pin). స్క్రిప్ట్ లోపల ఆ లైన్ version="${HEPHAESTUS_REF:-v1.2.0}" గా ఉంటుంది, కాబట్టి దానిని సెట్ చేయకుండా వదిలేస్తే, ప్రస్తుతం మీకు v1.2.0 లభిస్తుంది, కానీ వచ్చే వారం మరొకటి లభించవచ్చు. దానిని స్పష్టంగా సెట్ చేయండి, అప్పుడు మీరు ఆగస్టులో పరీక్షించిన వెర్షనే అక్టోబర్‌లో రీబిల్డ్ చేసినప్పుడు ఇన్‌స్టాల్ అవుతుంది.

ఒక ముఖ్యమైన పరిమితి: పైన పేర్కొన్న స్క్రిప్ట్ URL main ని ట్రాక్ చేస్తుంది, అయితే HEPHAESTUS_REF అనేది స్క్రిప్ట్ డౌన్‌లోడ్ చేసే రన్‌టైమ్ పేలోడ్‌ను పిన్ చేస్తుంది. ఇవి రెండూ వేర్వేరు విషయాలు. రెండింటినీ పిన్ చేయడానికి, main కి బదులుగా ఆ URL లోని main స్థానంలో v1.2.0 ని ఉంచి, ట్యాగ్ నుండి స్క్రిప్ట్‌ను పొందండి.

సక్సెస్‌ఫుల్‌గా రన్ అయినప్పుడు, అది రాసిన పాత్‌లను చూపిస్తుంది, అందులో ఈ రెండు లైన్లు ఉంటాయి:

Installed runner: /home/you/.agentlas/runtime/current/bin/hephaestus
Installed shell commands in /home/you/.local/bin (add ~/.local/bin to PATH to use them)

ఆ రెండో లైన్‌ను చాలామంది పట్టించుకోరు. కొత్తగా ఇన్‌స్టాల్ చేసిన Ubuntu బాక్స్‌లో ~/.local/bin తరచుగా PATH లో ఉండదు, కాబట్టి ఇన్‌స్టాలేషన్ విజయవంతమైనప్పటికీ ప్రతి hep-* కమాండ్ command not found తో విఫలమవుతుంది. దానిని సరిచేసి నిర్ధారించుకోండి:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
hep-global status

hep-global status గ్లోబల్ రౌటర్ ఏమి ఇన్‌స్టాల్ చేసిందో మరియు ఏ హార్నెస్‌లను గుర్తించిందో తెలియజేస్తుంది. అది రన్ అవుతుందంటే, మీ PATH సరిగ్గా ఉన్నట్లే.

స్టేట్ ఎక్కడ నిల్వ చేయబడుతుంది

మీ హోమ్ డైరెక్టరీలో ప్రతిదీ ఒక ఫైల్‌గా ఉంటుంది, దీనివల్ల బ్యాకప్ మరియు మైగ్రేషన్ సులభతరం అవుతాయి.

• ~/.agentlas/runtime/v1.2.0/ రన్‌టైమ్‌ను కలిగి ఉంటుంది, ఇందులో ~/.agentlas/runtime/current/ అనేది యాక్టివ్ వెర్షన్‌కు సిమ్‌లింక్ (symlink)గా పనిచేస్తుంది. రెండు పిన్ చేసిన వెర్షన్లు పక్కపక్కనే ఉండవచ్చు.
• ~/.local/bin/ షెల్ వ్రాపర్‌లను కలిగి ఉంటుంది: hephaestus, hep-build, hep-network, hep-search, hep-storm, hep-cloud మరియు hep-upload.
• ~/.agentlas/networking/memory/ మన్నికైన మెమరీని కలిగి ఉంటుంది: playbook-registry.json, playbook-candidates.jsonl మరియు memory-events.jsonl.
• ~/.agentlas/networking/hub-agents/<slug>/memory/experience.sqlite ప్రతి ఏజెంట్ యొక్క అనుభవాన్ని, యజమాని పరిధిని బట్టి నిల్వ చేస్తుంది.
• <project>/.agentlas/ontology-runtime.sqlite ప్రతి ప్రాజెక్ట్ యొక్క స్టేట్‌ను కలిగి ఉంటుంది, కాబట్టి ఇది సర్వర్‌తో సంబంధం లేకుండా రిపోజిటరీతో పాటు ప్రయాణిస్తుంది.
• ~/.cache/agentlas/python Linuxలో Python కాష్‌ను కలిగి ఉంటుంది. macOS వేరే పాత్‌ను ఉపయోగిస్తుంది, ఇది uname ద్వారా ఇన్‌స్టాలర్ ఎంచుకునే బ్రాంచ్.

సీక్రెట్స్, రా క్రెడెన్షియల్స్ మరియు పూర్తి ట్రాన్స్‌క్రిప్ట్‌లు ఏ మెమరీ పరిధిలోకి వెళ్లకూడదని మెమరీ డాక్యుమెంటేషన్ స్పష్టంగా పేర్కొంది. క్రెడెన్షియల్ విలువలు gitignore చేయబడిన లోకల్ ఫైళ్లలోనే ఉంటాయి, మెమరీ కేవలం పేర్లను మరియు పాత్‌లను మాత్రమే రికార్డ్ చేస్తుంది. ~/.agentlas మరియు మీ ప్రాజెక్ట్ .agentlas డైరెక్టరీలను బ్యాకప్ తీసుకోండి, దీనివల్ల మీరు కొత్త VPSలో వీటిని తిరిగి నిర్మించవచ్చు.

ఇది ఏ మోడల్ బ్యాకెండ్‌లను సూచించగలదు

మొత్తం సెటప్‌ను పునర్నిర్వచించే వివరాలు ఇక్కడ ఉన్నాయి: Agentlas నేరుగా మోడల్ APIని కాల్ చేయదు. హోస్ట్ హార్నెస్ (host harness) మాత్రమే అలా చేస్తుంది.

ఆర్కిటెక్చర్ డాక్యుమెంట్, ప్రతి హార్నెస్‌లోకి ఒక కోర్‌ను అనువదించే రన్‌టైమ్ అడాప్టర్ల గురించి వివరిస్తుంది మరియు మోడల్ క్రెడెన్షియల్స్ హోస్ట్ రన్‌టైమ్ ఆధీనంలో ఉంటాయని పేర్కొంటుంది. Agentlas రెండు ఉపరితలాలను (surfaces) అందిస్తుంది, వీటిని హార్నెస్ తీసుకుంటుంది: ఒక AgentSkills ఫైల్ మరియు stdio ద్వారా పనిచేసే MCP (model context protocol) సర్వర్. కాబట్టి "Agentlas ఏ మోడళ్లకు మద్దతు ఇస్తుంది" అనే ప్రశ్నకు అసలైన సమాధానం "మీ హార్నెస్ ఏ మోడళ్లకు మద్దతు ఇస్తుంది" అని అర్థం. Claude Code, Codex, opencode, goose లేదా Hermes ఏ మోడళ్లను చేరుకోగలవో, వాటన్నింటికీ ఇది మద్దతు ఇస్తుంది.

Codex-శైలి TOML కాన్ఫిగరేషన్‌లో MCP సర్వర్‌ను రిజిస్టర్ చేయడం ఇలా ఉంటుంది:

[mcp_servers.hephaestus-network]
command = "~/.agentlas/runtime/current/bin/hephaestus"
args = ["mcp", "serve"]

ఇన్‌స్టాలేషన్ సమయంలో ఇదే సర్వర్ ~/.cursor/mcp.json, ~/.config/goose/config.yaml మరియు ఇతర హార్నెస్ కాన్ఫిగరేషన్‌లలోకి స్వయంచాలకంగా రిజిస్టర్ అవుతుంది. మీరు వీటిలో కొన్నింటిని ఒకే బాక్స్‌లో అమర్చుతుంటే, running MCP servers on a VPS లో stdio మరియు ప్రాసెస్ మోడల్ గురించి మరింత వివరంగా చూడవచ్చు.

Self-hosted Ollama endpoint వైపు మళ్లించడం

Harness మోడల్ కనెక్షన్‌ను నియంత్రిస్తుంది కాబట్టి, Agentlas ను లోకల్ మోడల్స్‌కు అనుసంధానించాలంటే మీ harness ను Ollama వైపు మళ్లించాలి. Ollama v0.15 వెర్షన్‌లో దీని కోసం ప్రత్యేకంగా launch సబ్‌కమాండ్‌ను జోడించింది, ఇది 11 ఆగస్టు 2026 నాటికి v0.32.9 వెర్షన్‌లో కూడా అందుబాటులో ఉంది. ఇది ఎటువంటి environment variables సెట్ చేయాల్సిన అవసరం లేకుండానే, ఇప్పటికే ఉన్న harness ను లోకల్ మోడల్స్‌తో కాన్ఫిగర్ చేస్తుంది:

ollama pull qwen3-coder:30b
ollama launch opencode

మీరు ఇన్‌స్టాల్ చేసిన harness ను బట్టి opencode స్థానంలో claude, codex లేదా droid ను ఉపయోగించండి. ఆ తర్వాత లోకల్ రన్‌టైమ్ ద్వారా అభ్యర్థనను పంపండి:

~/.agentlas/runtime/current/bin/hephaestus route "summarise the failing tests" --runtime ollama

అభ్యర్థన విజయవంతమైతే, అది ఎంచుకున్న agent లేదా team పేరుతో కూడిన JSON నిర్ణయాన్ని, receipt_id తో సహా తిరిగి ఇస్తుంది. ఒకవేళ ఉపయోగకరమైన సమాచారం రాకపోతే, దానికి సాధారణంగా context length కారణం అవుతుంది. Agentlas డాక్యుమెంటేషన్ ప్రకారం, routing ఎక్కువగా ఉండే సెషన్ల కోసం కనీసం 64k context ఉన్న మోడల్ అవసరం. దీనికి ఉదాహరణలుగా qwen3-coder, gemma3 మరియు deepseek-r1 లను పేర్కొంది. కోడింగ్ టూల్స్ కోసం Ollama ఇచ్చే సూచనలు కూడా ఇదే 64k కనీస పరిమితిని సూచిస్తాయి. Routing నిర్ణయాలు ప్రాంప్ట్‌లో agent inventory ని కలిగి ఉంటాయి, కాబట్టి 8k లేదా 32k context ఉన్న మోడల్ inventory ని కుదించివేసి తప్పుడు నిర్ణయాలు తీసుకుంటుంది.

ట్యాగ్‌లైన్‌లో చెప్పని ఒక ముఖ్యమైన విషయం ఉంది. Ollama, Gemma మరియు DeepSeek లకు సొంతంగా ఎటువంటి plugin లేదా command సిస్టమ్ లేదు, కాబట్టి అక్కడ /agentlas స్లాష్ కమాండ్లు పనిచేయవు. లోకల్-మోడల్ సెటప్‌లో మీరు సిస్టమ్‌ను MCP సర్వర్ మరియు hephaestus route కమాండ్ ద్వారా మాత్రమే నిర్వహించగలరు. ఇది సిస్టమ్ సామర్థ్యంలో కొంత తగ్గుదల అయినప్పటికీ, మోడల్ వెయిట్స్‌ను మీ స్వంత సర్వర్‌లోనే ఉంచుకోవడానికి మీరు చెల్లించే సహేతుకమైన మూల్యం.

నిష్క్రియంగా ఉన్న స్పెషలిస్టుల హబ్ RAMపై చూపే ప్రభావం

ఏమీ ఉండదు. ఇదే పూర్తి సమాధానం, దీనిని మీరు నమ్మడమే కాకుండా నిరూపించుకోవచ్చు.

అరువు తెచ్చుకున్న హబ్ స్పెషలిస్టులు ప్రాసెస్‌లుగా కాకుండా ప్యాకేజీ ఆర్టిఫాక్ట్‌లుగా వస్తాయి. ఒక స్పెషలిస్ట్ అంటే ఒక agent.md మరియు JSON ఫైళ్లతో కూడిన .agentlas/ డైరెక్టరీ: ట్రిగ్గర్లు మరియు సామర్థ్యాల కోసం routing-card.json, రైట్ బౌండరీల కోసం memory-map.json, మరియు అది ఒంటరిగా పనిచేస్తుందా లేదా టీమ్‌గా పనిచేస్తుందా అని తెలిపే mode-map.json. Hephaestus Network అనేది బ్యాక్‌గ్రౌండ్ సర్వీస్ లేని ఒక ఇన్-ప్రాసెస్ షెడ్యూలర్. పనుల మధ్యలో, మీరే స్వయంగా తనిఖీ చేసుకోండి:

pgrep -af hephaestus
systemctl --user list-units --type=service | grep -i agentlas
du -sh ~/.agentlas

మొదటి రెండు కమాండ్లు నిష్క్రియంగా ఉన్న బాక్స్‌పై ఏమీ చూపవు, ఎందుకంటే అక్కడ ఏదీ రన్ అవ్వడం లేదు. మూడవ కమాండ్ పార్క్ చేసిన హబ్ మీపై వేసే ఏకైక భారాన్ని చూపిస్తుంది, అదే డిస్క్ వినియోగం. మీరు ఉంచుకున్న స్పెషలిస్టుల సంఖ్య మరియు రన్‌టైమ్‌తో పాటు వచ్చే ఎంబెడ్డింగ్ మోడల్ పెరిగేకొద్దీ ఇది పెరుగుతుంది.

కాబట్టి మెమరీకి సంబంధించిన ప్రశ్న పూర్తిగా బర్స్ట్ (burst) గురించి మాత్రమే, మరియు ఆ బర్స్ట్ అనేది మీ హార్నెస్ మరియు మోడల్ బ్యాకెండ్. ఒకవేళ హార్నెస్ హోస్ట్ చేసిన APIతో కనెక్ట్ అయితే, రన్‌టైమ్ ఖర్చు కొన్ని వందల మెగాబైట్ల ప్రాసెస్ మాత్రమే. ఒకవేళ మీరు వెయిట్స్‌ను సెల్ఫ్-హోస్ట్ చేస్తే, ఆ వెయిట్స్‌కు అయ్యే ఖర్చే అసలైనది:

[
  {
    "label": "Hosted API model",
    "weights_gb": 0
  },
  {
    "label": "gemma3:4b",
    "weights_gb": 3.3
  },
  {
    "label": "gemma3:12b",
    "weights_gb": 8.1
  },
  {
    "label": "gemma3:27b",
    "weights_gb": 17
  },
  {
    "label": "qwen3-coder:30b",
    "weights_gb": 19
  }
]

ఇవి Ollama మోడల్ లైబ్రరీ నుండి ప్రచురించబడిన డౌన్‌లోడ్ పరిమాణాలు, బెంచ్‌మార్క్ రన్ నుండి తీసుకున్న కొలతలు కావు. 64k కాంటెక్స్ట్ కోసం KV కాష్ పైన పేర్కొన్న ప్రతి అంకెకు అదనంగా ఉంటుంది. Agentlas డాక్యుమెంట్లలో మొదట పేర్కొన్న మోడల్, qwen3-coder:30b, కాంటెక్స్ట్‌కు ముందే 19 GB వెయిట్స్‌ను కోరుకుంటుంది, మరియు 27B Gemma వేరియంట్ కూడా 17 GB అడుగుతుంది. ఈ సంఖ్యలతో పోలిస్తే, Agentlas లేయర్ స్వయంగా బడ్జెట్‌లో ఎక్కడా కనిపించదు.

ఒక హార్నెస్‌ను రన్ చేయడంతో ఇది ఎలా పోల్చబడుతుంది

ఒక హోస్ట్ చేసిన APIకి వ్యతిరేకంగా ఒక హార్నెస్‌ను రన్ చేసినప్పుడు, మీ VPS ఒకే ప్రాసెస్‌ను కలిగి ఉంటుంది. Agentlasను జోడిస్తే, అది అదే ఒకే ప్రాసెస్‌ను, అదనంగా ఫైళ్లను కలిగి ఉంటుంది. ఆర్కెస్ట్రేటర్ అనేది ఎక్కువ కాలం ఉండే అదనపు ప్రోగ్రామ్ కాదు, ఇది డిస్క్‌లోని ప్యాకేజీల నుండి సేకరించబడిన ఒక పెద్ద ప్రాంప్ట్, ఇది పని పూర్తయ్యాక తొలగించబడుతుంది.

ఇక్కడ మారే వ్యయం మెమరీ కాదు, కాంటెక్స్ట్. అనేక స్పెషలిస్ట్ కార్డ్‌లను మరియు వాటి రూటింగ్ మెటాడేటాను తీసుకునే ఆర్కెస్ట్రేటర్, సాధారణ హార్నెస్ కంటే ప్రతి టాస్క్‌కు ఎక్కువ టోకెన్‌లను ఖర్చు చేస్తుంది. హోస్ట్ చేసిన APIపై ఇది RAM కంటే డబ్బుతో కూడుకున్న వ్యవహారం. లోకల్ వెయిట్స్ (local weights) విషయంలో ఇది సమయంతో కూడుకున్నది, ఎందుకంటే పొడవైన ప్రాంప్ట్ అంటే CPUపై ఎక్కువ ప్రీఫిల్ (prefill) లేదా బిజీగా ఉండే GPU అని అర్థం.

అందుకే ఇటువంటి బాక్స్ కోసం సైజింగ్ సలహా అనేది ఏజెంట్ ఫ్రేమ్‌వర్క్ కాకుండా, మోడల్ నిర్ణయంపై ఆధారపడి ఉంటుంది. కోడింగ్ ఏజెంట్ VPS కోసం RAM మరియు CPU సైజింగ్ దీని గురించి వివరంగా వివరిస్తుంది, మరియు దాని ముగింపు ఇక్కడ కూడా వర్తిస్తుంది: మీరు రన్ చేయాలనుకుంటున్న బ్యాకెండ్ కోసం ప్లాన్‌ను ఎంచుకోండి, ఆపై హార్నెస్ కోసం అదనంగా కొన్ని గిగాబైట్ల హెడ్‌రూమ్‌ను జోడించండి. దీనికి భిన్నంగా మీరు ఎల్లప్పుడూ ఆన్‌లో ఉండే సూపర్వైజర్ డిజైన్‌ను కోరుకుంటే, Omnigent మల్టీ-ఏజెంట్ హార్నెస్ దాని కోఆర్డినేటర్‌ను నిరంతరం రన్ అయ్యేలా ఉంచుతుంది. ఇది దీనికి పూర్తి విరుద్ధమైన పద్ధతి మరియు ఇది ఖాళీగా ఉన్నప్పుడు మెమరీ వినియోగంలో నేరుగా కనిపిస్తుంది.

వైఫల్య రీతులు మరియు మీకు కనిపించే సందేశాలు

hep-build: command not found క్లీన్ ఇన్‌స్టాల్ తర్వాత వెంటనే. ఇన్‌స్టాలర్ ~/.local/bin లోకి వ్రాసింది, ఇది డిఫాల్ట్ Ubuntu ఇమేజ్‌లో PATH పై ఉండదు. ఇది చివరి లైన్‌లో చెప్పబడింది మరియు ఆ లైన్ స్క్రోల్ అయిపోయింది. పైన చూపిన export ను జోడించండి.

మీరు బాక్స్‌ను రీబిల్డ్ చేసిన తర్వాత ప్రవర్తనలో మార్పులు. మీరు HEPHAESTUS_REF ను సెట్ చేయలేదు, కాబట్టి ఇన్‌స్టాలర్ ఆ రోజున కరెంట్‌గా ఉన్న ట్యాగ్‌ను డిఫాల్ట్‌గా తీసుకుంది. దాన్ని పిన్ చేయండి మరియు మీ ఇతర వెర్షన్ నంబర్ల పక్కన ఆ పిన్‌ను రికార్డ్ చేయండి.

లోకల్ మోడల్‌పై రూటింగ్ తప్పు స్పెషలిస్ట్‌ను ఎంచుకుంటుంది. ఏజెంట్ ఇన్వెంటరీకి మోడల్ యొక్క కాంటెక్స్ట్ విండో చాలా చిన్నదిగా ఉంది. 64k లేదా అంతకంటే ఎక్కువ ఉన్న మోడల్‌కు మారండి మరియు Ollama యొక్క కాంటెక్స్ట్ లెంగ్త్‌ను దానికి అనుగుణంగా సెట్ చేయండి, ఎందుకంటే డిఫాల్ట్ విలువ కోడింగ్ టూల్స్ ఆశించే దానికంటే తక్కువగా ఉంటుంది.

ollama launch గుర్తించబడలేదు. ఈ సబ్‌కమాండ్ Ollama v0.15 లో వచ్చింది. డిస్ట్రిబ్యూషన్ రిపోజిటరీ నుండి వచ్చిన పాత ప్యాకేజీలు దీనికంటే ముందువి, కాబట్టి ప్రస్తుత Ollama వెర్షన్‌ను ఇన్‌స్టాల్ చేయండి.

ఇన్‌స్టాల్ మీరు ఊహించని హార్నెస్‌లలోకి వ్రాస్తుంది. స్క్రిప్ట్ అది కనుగొనే ప్రతి హార్నెస్‌ను గుర్తించి కాన్ఫిగర్ చేస్తుంది, ఇది ~/.claude/, ~/.codex/, ~/.gemini/, ~/.cursor/ మరియు మరిన్నింటిలోకి వ్రాస్తుంది. షేర్డ్ బిల్డ్ బాక్స్‌లో, స్క్రిప్ట్‌ను రన్ చేసే ముందు దాన్ని చదవండి మరియు ఆ డైరెక్టరీలలో మీకు ఏవి ముఖ్యమో తెలుసుకోండి.

దీనిని ఇప్పుడే అమలు చేయాలా

పది వారాల వయస్సు ఉండి, రోజుకు అనేకసార్లు ఆటోమేటెడ్ releases పొందే ప్రాజెక్ట్‌ను production workload కోసం ఉపయోగించకూడదు. దీని ఆర్కిటెక్చర్ ఆసక్తికరంగా ఉంది, లైసెన్స్ Apache-2.0, మరియు ఫైల్-ఆధారిత డిజైన్ కారణంగా అన్‌ఇన్‌స్టాల్ చేయడం అంటే కేవలం రెండు డైరెక్టరీలను తొలగించడమే. ఈ కారణాల వల్ల దీనిని ప్రయత్నించడం సులభం, కానీ దీనిపై ఆధారపడటం ఖరీదైనది.

ప్రస్తుతానికి ఒక సమంజసమైన పద్ధతి: v1.2.0 వెర్షన్‌ను పిన్ చేయండి, మీరు తిరిగి నిర్మించగల (rebuild) సర్వర్‌పై దీనిని రన్ చేయండి, మీ బ్యాకప్‌లలో ~/.agentlas ను ఉంచండి, మరియు పిన్‌ను మార్చే ముందు changelog ను మళ్ళీ చదవండి. ఈ విభాగంలో ఉన్న ఇతర ఎంపికలు మరియు వాటి పరిణతి గురించి మరింత సమాచారం కోసం, self-hosted AI agents యొక్క సమగ్ర పరిశీలన మెరుగైన ప్రారంభ స్థానం, మరియు VPS పై Hermes agent ను self-host చేయడం అనేది Agentlas అనుకూలించే హార్నెస్‌లలో ఒకదానిని వివరిస్తుంది.

FAQ

Agentlas OS నా VPSలో సర్వర్‌గా నడుస్తుందా?

లేదు. ఇందులో ఎటువంటి daemon లేదు, ఏ port కూడా listen చేయదు మరియు repositoryలో ఎటువంటి container image లేదు. installer ఒక runtimeను ~/.agentlas/runtime/ కింద, మరియు command wrappersను ~/.local/bin లోకి వ్రాస్తుంది. Hephaestus Network అనేది background service కాదు, ఇది ఒక in-process scheduler. ఖాళీగా ఉన్న సర్వర్‌లో మీరు దీన్ని నిర్ధారించుకోవచ్చు: pgrep -af hephaestus ఏమీ చూపించదు, మరియు enable చేయడానికి ఎటువంటి systemd unit ఉండదు. ఇక్కడ self-hosting అంటే కోడ్ మరియు state మీ మెషీన్‌లో ఉండటం అని అర్థం, ఏదైనా service listen చేయడం అని కాదు.

ఖాళీగా ఉన్న specialists హబ్ ఎంత RAMను వినియోగిస్తుంది?

ఏమీ వినియోగించదు, ఎందుకంటే ఖాళీగా ఉన్న specialists అనేవి processes కావు. ఒక specialist అంటే ఒక agent.md ఫైల్ మరియు దానితో పాటు routing-card.json, memory-map.json వంటి metadataను కలిగి ఉన్న ఒక .agentlas/ డైరెక్టరీ. కాబట్టి, నిలిపి ఉంచిన హబ్ కేవలం disk స్థలాన్ని మాత్రమే తీసుకుంటుంది. దీన్ని du -sh ~/.agentlas తో కొలవవచ్చు. ఒక task నడుస్తున్నప్పుడు మాత్రమే మెమరీ వినియోగించబడుతుంది, మరియు ఆ మెమరీని మీ harness process మరియు model backend వినియోగిస్తాయి, Agentlas layer కాదు.

నేను ఏ మోడల్స్‌ను ఉపయోగించగలను, మరియు నా స్వంత Ollamaకు దీన్ని అనుసంధానించవచ్చా?

Agentlas స్వయంగా model APIలను కాల్ చేయదు. host harness వద్దే credentials మరియు connection ఉంటాయి, కాబట్టి మీ harness ఏ మోడల్స్‌కు మద్దతు ఇస్తే, అవే మీకు అందుబాటులో ఉంటాయి. స్థానిక weights కోసం, ollama launch opencode రన్ చేయండి (claude, codex లేదా droid లను మార్చుకుంటూ), ఇది ఎటువంటి environment variables అవసరం లేకుండా మీ Ollama సర్వర్‌తో harnessను కాన్ఫిగర్ చేస్తుంది. కనీసం 64k context ఉన్న మోడల్‌ను ఉపయోగించండి, ఉదాహరణకు qwen3-coder లేదా gemma3. ఎందుకంటే routing prompts ఏజెంట్ ఇన్వెంటరీని కలిగి ఉంటాయి, ఇవి చిన్న విండోస్‌లో సరిగ్గా సరిపోవు (truncate అవుతాయి).

నేను ఏ వెర్షన్‌ను ఇన్‌స్టాల్ చేయాలి, మరియు ఇక్కడ pinning ఎందుకు ముఖ్యం?

12 ఆగస్టు 2026 నాటికి అందుబాటులో ఉన్న tagged release అయిన v1.2.0ను ఇన్‌స్టాల్ చేయండి. దీని కోసం installer రన్ చేసే ముందు HEPHAESTUS_REF=v1.2.0 ను సెట్ చేయండి. స్క్రిప్ట్ యొక్క డిఫాల్ట్ విలువ version="${HEPHAESTUS_REF:-v1.2.0}", ఇది maintainers తర్వాత ఏ వెర్షన్‌ను tag చేస్తే దాన్ని ట్రాక్ చేస్తుంది. Pinning సాధారణం కంటే ఇక్కడ చాలా ముఖ్యం, ఎందుకంటే ఈ ప్రాజెక్ట్ 1.1 సిరీస్‌లో వందకు పైగా releases విడుదల చేసింది, కొన్ని రోజుల్లోనే ఒకటి కంటే ఎక్కువ releases వచ్చాయి. కాబట్టి, pinning చేయకుండా వారాల తర్వాత rebuild చేస్తే, మీరు పరీక్షించిన సిస్టమ్ మీకు లభించదు.