SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

VPSలో open-kritt ను self-host చేయడం ఎలా

Docker Compose ద్వారా VPSలో open-kritt ను సురక్షితంగా సెటప్ చేయండి. పోర్ట్ 5173 కోసం SSH టన్నెల్, రిలీజ్ పిన్నింగ్ మరియు మొదటి స్కాన్ ముందు సెట్ చేయాల్సిన బడ్జెట్ వివరాలు ఇక్కడ ఉన్నాయి.

VPS పై self-host open-kritt ను ఎందుకు నడపాలి, మీ laptop పై ఎందుకు కాదు

మీరు ధ్వంసం చేసి మళ్లీ నిర్మించగల server పై self-host open-kritt ను నడపండి. ఈ tool తన analysis agents ను disposable job containers లో root గా నడుపుతుంది. ప్రతి agent కు మీ code యొక్క వ్రాయగలిగే copy మరియు నేరుగా internet access ఇస్తుంది. అలాగే host Docker socket ను దాని engine service లో mount చేస్తుంది. ఈ job కు ప్రత్యేకంగా కేటాయించిన machine పై ఇది సముచితమైన trade-off. కానీ మీ SSH keys ఉన్న machine పై ఇది ప్రమాదకరమైన ఎంపిక.

Default setup కు సంబంధించిన నాలుగు లక్షణాలు ఈ సూచనకు కారణం. ఈ నాలుగూ project యొక్క స్వంత README మరియు compose file నుంచి వస్తాయి.

Agents శక్తివంతంగా ఉండేలా రూపొందించబడ్డాయి. Tool-enabled agents disposable job containers లో root గా నడుస్తాయని README చెబుతుంది. వాటికి writable repository copies మరియు direct internet access ఉంటాయి. అందువల్ల అవి tools install చేయగలవు, targets compile చేయగలవు, tests run చేయగలవు, proof-of-conceptలను build చేయగలవు. Scan అనేది files చదివే linter కాదు. మీరు ఆదేశించిన arbitrary code execution అది. ఈ internet access రెండు విధాలా ప్రభావం చూపుతుంది: target ను పరిశీలించేటప్పుడు agent fetch చేసే ఏదైనా విషయం నమ్మదగని text గా దాని prompt లోకి వస్తుంది. మీరు agent కు దాని స్వంత web search అందించినప్పుడు ఎదుర్కొనే exposure ఇదే.

Engine వద్ద Docker socket ఉంటుంది. docker-compose.yml host Docker socket ను engine service లో mount చేస్తుంది. ఎందుకంటే engine ప్రతి job కోసం ఒక scan container ను build చేసి launch చేస్తుంది. ఆ socket ను చేరుకోగల ఏ process అయినా host filesystem ను mount చేసే container ను start చేయగలదు. అందువల్ల దాన్ని నడుపుతున్న host పై engine వాస్తవంగా root అధికారాలతో పనిచేస్తుంది.

Login screen లేదు. Backend లో application authentication అందుబాటులో ఉండదు. Port కు access అంటే మీ findings కు మరియు మీ provider credit కు access ఉన్నట్టే.

మీరు scan చేసే code తరచుగా మీది కాదు. Third-party repository పై agents ను నడపడం అంటే, ఆ repository యొక్క build ను మీ machine పై root గా, network access తో run చేయడం.

coding agents ను disposable VM లో ఉంచాల్సిన కారణం మీరు చదివి ఉంటే, ఇదే threat model, కానీ మరింత బలమైనది. open-kritt కోసం మాత్రమే ఉపయోగించే VPS ను ఇవ్వండి. ఆ VPS ను root బదులుగా వేరు చేసిన least-privilege user account నుంచి నిర్వహించండి.

open-kritt వాస్తవంగా ఏమి చేస్తుంది

open-kritt (దీని repository Kritt-ai/open-kritt, లైసెన్స్ AGPL-3.0) vulnerability research ను చిన్న పనులుగా విభజిస్తుంది. ఆ పనులను అనేక AI agents పై సమాంతరంగా అమలు చేస్తుంది. తరువాత తిరిగి వచ్చిన ఫలితాల్లో duplicate అంశాలను తొలగించి, వాటికి ప్రాధాన్యత క్రమాన్ని నిర్ణయిస్తుంది. మీరు workflow ను పరస్పరం అనుసంధానమైన focused prompts శ్రేణిగా నిర్వచిస్తారు. ప్రతి దశకు దాని ముందు దశల నుంచి structured context అందుతుంది. scan target remote లేదా local git repository కావచ్చు. analysis engine Codex లేదా Claude Code. ఒక candidate కనిపించిన తరువాత, optional post-scripts దాన్ని validate చేయడానికి లేదా proof of concept రూపొందించడానికి ప్రయత్నించవచ్చు. ఈ chain రూపకల్పన security work కంటే సాధారణ agent work కు దగ్గరగా ఉంటుంది. అందువల్ల prompts, tools మరియు context passing ఇంకా మీకు పరిచయం లేకపోతే, agents ఎలా రూపొందించబడతాయో నేర్చుకోవడం ఈ guide లోని ఏ setting కంటే మీ ఫలితాలను ఎక్కువగా మెరుగుపరుస్తుంది.

చివరికి మీకు లభించేది candidates యొక్క ప్రాధాన్యత క్రమ జాబితా. దాన్ని report గా కాకుండా triage queue గా పరిగణించండి.

ప్రారంభించడానికి ముందు మీకు కావాల్సినవి

  • Ubuntu 24.04, Debian 12 లేదా Rocky Linux 9 నడుస్తున్న ఒక VPS. ఇన్‌స్టాలేషన్ డాక్యుమెంట్లు x86_64 మరియు ARM64 ఆర్కిటెక్చర్‌లపై ఈ డిస్ట్రిబ్యూషన్లను పరీక్షించినట్లు పేర్కొన్నాయి.
  • Compose ప్లగిన్‌తో కూడిన Docker Engine.
  • హోస్ట్‌లో Node.js 20 లేదా అంతకంటే కొత్త వెర్షన్. ఎందుకంటే ./kritt CLI కంటైనర్ లోపల కాకుండా హోస్ట్‌పైనే రన్ అవుతుంది.
  • ఒక మోడల్ ప్రొవైడర్: ఒక Codex లాగిన్, లేదా OPENAI_API_KEY, CODEX_API_KEY, ANTHROPIC_API_KEY లేదా OPENROUTER_API_KEY.
  • మీరు ప్రైవేట్ రిపోజిటరీలను స్కాన్ చేయాలనుకుంటే మాత్రమే GITHUB_TOKEN అవసరం. అందించబడిన .env.example దీనిని స్పష్టంగా తెలియజేస్తుంది: కేవలం GitHub టోకెన్‌తో స్కాన్‌లను రన్ చేయడం సాధ్యం కాదు.

ముందుగా Docker మరియు Node 20 ను ఇన్‌స్టాల్ చేయండి

curl -fsSL https://get.docker.com | sudo sh
sudo usermod -aG docker $USER

కొత్త group membership వర్తించేందుకు log out చేసి మళ్లీ log in చేయండి. తరువాత Compose plugin అందుబాటులో ఉందో నిర్ధారించండి.

docker compose version

Version string కనిపిస్తే Compose plugin గా ఇన్‌స్టాల్ అయిందని అర్థం. docker: 'compose' is not a docker command కనిపిస్తే, బదులుగా పాత standalone docker-compose binary ఉంది. open-kritt docker compose ను పిలుస్తుంది. docker group కు membership host పై root కు సమానమైన అధికారాలను ఇస్తుంది. అందువల్ల open-kritt నడిపే account ను మాత్రమే ఈ group లో చేర్చండి. ఈ setup యొక్క విస్తృత వివరణ కోసం VPS పై Docker నడపడం చూడండి.

Ubuntu 24.04 తన స్వంత repository లో Node 18 ను అందిస్తుంది. అయితే CLI, 20 కంటే తక్కువ version పై వెంటనే exit అవుతుంది. Node 20 కూడా అప్పటికే end of life కు చేరింది. అందువల్ల దీనికి updates అందవు. కాబట్టి NodeSource నుంచి Node 22 ను ఇన్‌స్టాల్ చేయండి. ఇది అదే 20-or-newer check ను సంతృప్తిపరుస్తుంది.

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node -v

ఇక్కడ node -v తప్పనిసరిగా v22. ను print చేయాలి. v20. కంటే తక్కువ ఏ version అయినా CLI నిరాకరిస్తుంది. Rocky Linux 9 లో దీనికి సమానమైనది ముందుగా sudo dnf module enable nodejs:22 -y, తరువాత sudo dnf install -y nodejs.

open-kritt ను క్లోన్ చేసి tagged release కు pin చేయండి

git clone https://github.com/Kritt-ai/open-kritt
cd open-kritt
git fetch --tags
git tag --list
git checkout v1.4.1

main మీ కింద మారుతుంది. Tag మారదు. 12 October 2026 నాటికి తాజా tag v1.4.1. ఇది 16 August 2026 న ప్రచురించబడింది. మీరు క్లోన్ చేసే రోజున అందుబాటులో ఉన్నదాన్ని git tag --list చూపిస్తుంది. v1.4.0 (12 August 2026) sizing కింద వివరించిన memory-aware runner admission ను జోడించింది. v1.4.1లో ranker, వినియోగదారు అందించిన ranking rules ను పట్టించుకోని లోపం సరిచేయబడింది. Tag కు checkout చేస్తే repository detached HEAD state లో ఉంటుంది. ఇక్కడ ఇది సరైనదే. ఈ clone ను commit చేసే branch గా కాకుండా, నిర్దిష్ట version కు pin చేసిన deployment గా ఉపయోగిస్తున్నారు. తరువాత upgrade చేయాలంటే release notes చదవండి. ఆ తరువాత git fetch --tags అమలు చేసి, కొత్త tag కు checkout చేయండి. చివరగా ./kritt start ను మళ్లీ అమలు చేయండి. ఎందుకంటే start images ను మళ్లీ build చేస్తుంది.

sudo తో కలిసి ./kritt ను అమలు చేయవద్దు. Documentation లో ఇది స్పష్టంగా పేర్కొనబడింది. CLI, project-local credential directories ను .data/ కింద నిర్వహిస్తుంది. అందువల్ల root గా అమలు చేస్తే ఆ directories root యాజమాన్యంలోకి మారతాయి. తరువాత సాధారణ వినియోగదారుగా అమలు చేసినప్పుడు వాటిలో రాయలేరు.

./kritt setup తో మోడల్ యాక్సెస్‌ను కాన్ఫిగర్ చేయడం

./kritt setup

ఈ కమాండ్ .env.example ఫైల్ లేనప్పుడు దాని నుండి .env ను సృష్టిస్తుంది, ప్రతి క్రెడెన్షియల్ స్థితిని ప్రింట్ చేస్తుంది మరియు వాటిని సెట్ చేయడానికి లేదా అన్‌సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇది ఎప్పుడూ విలువలను టెర్మినల్‌లో ప్రింట్ చేయదు. .env మరియు ఇంజిన్ క్రెడెన్షియల్ ఫైల్ రెండూ 0600 మోడ్‌తో వ్రాయబడతాయి.

ఒకవేళ మీరు దీన్ని మాన్యువల్‌గా చేయాలనుకుంటే:

cp .env.example .env
chmod 600 .env
mkdir -p .data/codex
chmod 700 .data/codex

ఆ తర్వాత ప్రొవైడర్ కీని .env లో ఎడిట్ చేయండి మరియు ఫైల్ పర్మిషన్లను 0600 వద్ద ఉంచండి. ఏ పద్ధతిలో చేసినా, ఇప్పుడు ఆ సర్వర్‌పై పనిచేసే ప్రొవైడర్ క్రెడెన్షియల్ సిద్ధంగా ఉంటుంది; ఆ సర్వర్‌లో మరే ఇతర ముఖ్యమైన డేటా ఉండకూడదు అనడానికి ఇది కూడా ఒక కారణం. ఈ ప్రాజెక్ట్ కోసం మాత్రమే ఒక ప్రత్యేక కీని సృష్టించండి, తద్వారా భవిష్యత్తులో దాన్ని రద్దు చేసినా మీకు సంబంధించిన ఇతర పనులు ఆగిపోవు. AI ఏజెంట్లకు అందకుండా రహస్యాలను భద్రపరచడం అనే విభాగం దీనికి సంబంధించిన విస్తృత అలవాట్లను వివరిస్తుంది.

మొదటి scan కు ముందు provider spending cap సెట్ చేయండి

open-kritt అనేక పనులను ఏకకాలంలో పంపేలా రూపొందించబడింది. మీరు చెల్లించేది కూడా ఆ fan-out కోసం. v1.4.1లోని .env.example default విలువలు సంయమనంతో ఉన్నాయి: ENGINE_WORKER_COUNT=2. ఫైల్‌లో దీన్ని చిన్న 2-vCPU machine కోసం conservative default గా వివరించారు. అలాగే ENGINE_MAX_CONCURRENT_SCANS=1 కూడా ఉంది. వీటి కంటే పై స్థాయిలో ENGINE_WORKERS_PER_ACCOUNT=15 ఉంటుంది. ఇది ఒక provider account పై ఒకేసారి అనుమతించే గరిష్ఠ root model calls సంఖ్య. అలాగే ENGINE_CODEX_MAX_SUBAGENTS_PER_SESSION=5 ఉంటుంది, ఎందుకంటే ఒక Codex session గరిష్ఠంగా ఐదు child agents ను అమలు చేయవచ్చు. పెద్ద VPS పై worker count పెంచితే, ఒకేసారి జరుగుతున్న model calls సంఖ్య కూడా పెరుగుతుంది.

మీరు ఖర్చు చేసే మొత్తానికి repository లో ఎలాంటి cap లేదు. .env.example లో budget setting లేదు. Engine యొక్క స్వంత stop conditions worker limits మరియు ENGINE_HARNESS_TIMEOUT_SECONDS మాత్రమే. ఇది ప్రతి harness run కు default గా 7200 seconds. ఇక్కడ harness అంటే tools మరియు context తో model ను పదేపదే పిలుస్తూ, run ముగిసే వరకు కొనసాగించే loop. అందువల్ల ఆ timeout model చుట్టూ అమర్చిన program పై wall-clock పరిమితి మాత్రమే. దాని లోపల model చేసే ఖర్చుపై అది పరిమితి కాదు. కాబట్టి ఈ ceiling provider వద్ద ఉండాలి. మొదటి scan కు ముందే మీ provider console తెరిచి hard monthly limit సెట్ చేయండి. scan పూర్తయ్యాక సెట్ చేయకండి. VPS పై AI agent ఖర్చును నియంత్రించడం ప్రతి provider కు సంబంధించిన settings ను వివరిస్తుంది.

స్థానికంగా కూడా ఒక brake ఉంది. ENGINE_WORKER_COUNT=0 సెట్ చేస్తే కొత్త jobs స్వీకరించడం pause అవుతుంది. Stack నడుస్తున్న తర్వాత Settings screen లో అదే worker విలువలను మార్చవచ్చు.

ప్రతి scan కు అయ్యే ధరను ఈ guide పేర్కొనదు. ఖర్చు repository పరిమాణం, మీరు రూపొందించే workflow మరియు దాని వెనుక ఉన్న model పై ఆధారపడి ఉంటుంది. ఒక చిన్న repository పై ఒక scan అమలు చేయండి. తరువాత దాన్ని పెద్ద repository పై ఉపయోగించే ముందు మీ provider usage page ను పరిశీలించండి.

స్టాక్‌ను ప్రారంభించి అది ఆరోగ్యంగా ఉందో లేదో తనిఖీ చేయండి

./kritt start

ఇది .env మరియు కనీసం ఒక క్రెడెన్షియల్‌ను తనిఖీ చేస్తుంది, ఆపై docker compose up --buildని రన్ చేస్తుంది. మొదటి బిల్డ్ నెమ్మదిగా ఉంటుంది, ఎందుకంటే ఇది frontend, backend, engine, executor view మరియు database ఇమేజ్‌లను బిల్డ్ చేస్తుంది. ఇది ఫోర్‌గ్రౌండ్‌లో కూడా రన్ అవుతుంది, కాబట్టి SSH సెషన్‌ను క్లోజ్ చేస్తే స్టాక్ ఆగిపోతుంది. దీన్ని tmux లోపల ప్రారంభించండి, లేదా మొదటి బిల్డ్ విజయవంతమైన తర్వాత దీన్ని డిటాచ్డ్ మోడ్‌లో రన్ చేయండి. వీటిలో ఏదీ రీబూట్ తర్వాత స్వయంచాలకంగా ప్రారంభం కాదు, కాబట్టి సర్వర్ రీస్టార్ట్ అయిన తర్వాత స్టాక్ మళ్లీ అందుబాటులోకి రావాలంటే, keeping a self-hosted agent running across reboots లోని systemd యూనిట్ పద్ధతిని నేరుగా ఉపయోగించవచ్చు.

docker compose up -d --build
docker compose ps

docker compose ps కమాండ్ open-kritt-frontend, open-kritt-backend, open-kritt-engine, open-kritt-executor-view మరియు open-kritt-db లను చూపించాలి. ఆ తర్వాత సర్వర్‌లోనే backend స్పందిస్తుందో లేదో తనిఖీ చేయండి.

curl -s http://127.0.0.1:3002/api/health

JSON రెస్పాన్స్ వచ్చిందంటే backend రన్ అవుతున్నట్లు అర్థం. Failed to connect to 127.0.0.1 port 3002: Connection refused అంటే అది రన్ అవ్వడం లేదని, మరియు docker compose logs backend ఎందుకు రన్ అవ్వడం లేదో చెబుతుంది. రిపోజిటరీ డైరెక్టరీ నుండి docker compose down ఉపయోగించి అన్నింటినీ ఆపివేయండి.

ఒక అదనపు ఆప్షన్: docker compose exec backend npm run seed డెమో డేటాను లోడ్ చేస్తుంది, ఇది నిజమైన స్కాన్ కోసం ఖర్చు చేసే ముందు ఇంటర్‌ఫేస్‌ను చూడటానికి సులభమైన మార్గం.

SSH tunnel ద్వారా port 5173పై UIను తెరవండి

compose fileలోని ప్రతి service డిఫాల్ట్‌గా 127.0.0.1 కు bind అవుతుంది: frontend 5173పై, backend 3002పై, executor view 8090పై, Postgres 5432పై. ఈ bindings ను అలాగే ఉంచి, మీ స్వంత machine నుంచి SSH ద్వారా port ను forward చేయండి.

ssh -N -L 5173:127.0.0.1:5173 you@your-server-ip

ఆ command నడుస్తున్న సమయంలో మీ local browserలో http://localhost:5173 ను తెరవండి. -N అంటే connection forward ను నిర్వహించి, shellను ప్రారంభించదని అర్థం. executor view కూడా కావాలంటే అదే commandకు రెండవ -L 8090:127.0.0.1:8090 ను జోడించండి.

FRONTEND_BIND_ADDRESS=0.0.0.0 ను సెట్ చేసి tunnelను వదిలేయాలనే ఆలోచన రావచ్చు. అలా చేయవద్దు. backendలో login screen లేదు. కాబట్టి ఆ pageను చేరగల ఎవరైనా scans ప్రారంభించి, మీ provider creditను ఖర్చు చేయవచ్చు. దీనికి భిన్నంగా, Vaultwarden internet-facing ఉపయోగం కోసం రూపొందించబడింది. అయితే దానిని harden చేయడం ఇప్పటికీ admin token మరియు backup fileపైనే ఆధారపడి ఉంటుంది. open-krittలో ఈ నియంత్రణలు అందుబాటులో ఉండవు. దీనికి మరో సమస్య కూడా ఉంది: ufw యొక్క default policy వర్తించే ముందు published container portను process చేస్తారు. అందువల్ల ufw deny 5173 rule సరైనదిగా కనిపించినా ఏదీ block చేయదు. ufwను దాటే Docker ports దీనికి కారణమయ్యే rule chainను చూపిస్తుంది.

VPS పరిమాణాన్ని నిర్ణయించడం

ENGINE_MIN_FREE_STORAGE_GB డిఫాల్ట్‌గా 20గా ఉంటుంది. Free storage దీని కంటే తక్కువగా ఉన్నప్పుడు, ప్రతి job కోసం కొత్త scan container ప్రారంభించడాన్ని engine నిరాకరిస్తుంది. Built images, checkout cache, Postgres data, job workspaces అన్నీ ఒకే diskలో ఉంటాయి. అందువల్ల 20 GB VPSలో scan అసలు ప్రారంభం కాదు. కనీస పరిమాణంగా 40 GBను పరిగణించండి. పెద్ద repositoriesను scan చేస్తే ఇంకా ఎక్కువ storage కేటాయించండి. ఈ VPSను తిరిగి ఉపయోగించుకోవాలనే ఉద్దేశంతో storage ఎక్కువగా వినియోగించే serviceను దాని పక్కన నడపవద్దు. PhotoPrism మరియు Immich పోలికలోని ఈ విశ్లేషణ చూపించే measured RAM మరియు disk కనీస అవసరాలు, scanకు అవసరమైన headroomను media library ఎంత వేగంగా వినియోగిస్తుందో స్పష్టం చేస్తాయి. Scanner పక్కన తక్కువ వనరులు మాత్రమే అవసరమయ్యేలా కనిపించే అదనపు సేవల విషయంలో కూడా ఇదే వర్తిస్తుంది: Jellyfin libraryను 90s rental storeలా మళ్లీ రూపకల్పన చేసే browser front end వెనుక మొత్తం media server మరియు దాని transcodesను diskపై ఉంచుతుంది. అందువల్ల దానికి వేరే host కేటాయించండి.

Memory అవసరాన్ని సరళమైన లెక్కతో నిర్ణయించవచ్చు. దీనికి సంబంధించిన settings v1.4.0లో వచ్చాయి. కాబట్టి అవి పైన pin చేసిన tagకు వర్తిస్తాయి, పాత tagsకు కాదు. ENGINE_MEMORY_RESERVE_GB=2 engine, database, API మరియు తాత్కాలిక overhead కోసం కొంత memoryను రిజర్వ్ చేస్తుంది. ప్రతి scan runnerకు ENGINE_SCAN_RUNNER_MEMORY_RESERVATION_MB=1536 soft reservation మరియు ENGINE_SCAN_RUNNER_MEMORY_MB=1536 hard cap ఉంటాయి. కాబట్టి మరే ఇతర పని ప్రారంభం కాకముందే ఇద్దరు workersకు సుమారు 5 GB అవసరం. మిగిలిన memory budgetలో సరిపోయే runnersను మాత్రమే engine అనుమతిస్తుంది. అందువల్ల చిన్న boxలో scans విఫలమయ్యే బదులు queueలో వేచి ఉంటాయి. ఇది out-of-memory killer వల్ల కలిగే failure కంటే చాలా మెరుగైన విధానం. ప్రతి పని భాగానికి ప్రత్యేక container ఇచ్చే ఏ toolకైనా ఇదే లెక్క వర్తిస్తుంది. అందుకే ప్రతి AI coworkerకు ఒక container మరియు browserను నడిపే OpenBot CPU పరిమితిని ఎదుర్కొనే ముందు RAM పరిమితిని ఎదుర్కొంటుంది.

రెండు prune settings డిఫాల్ట్‌గా trueగా ఉంటాయి: ENGINE_AUTO_PRUNE_DOCKER_BUILD_CACHE మరియు ENGINE_AUTO_PRUNE_UNUSED_DOCKER_IMAGES. Task పూర్తయ్యాక engine ఉపయోగించని build cache, ఉపయోగించని images మరియు ఆపివేసిన scan containersను తొలగిస్తుంది. ఏ container అయినా ఉపయోగిస్తున్న images, service containers, bind mounts, database data, credentials మరియు volumes భద్రంగా ఉంచబడతాయి. Hostను పంచుకోకూడదనడానికి ఇది మరో కారణం. మీరు configure చేయని pruner ఆ Docker daemonపై పనిచేస్తోంది.

చాలామంది చివరికి మార్చే engine settings
  • ENGINE_WORKER_COUNT: scan steps మరియు post-processing పంచుకునే మొత్తం worker slots. కొత్త jobsను స్వీకరించడం నిలిపివేయడానికి దీన్ని 0గా సెట్ చేయండి.
  • ENGINE_MAX_CONCURRENT_SCANS: ఒకేసారి అనుమతించే scans సంఖ్య. Active pool ఖాళీ అయ్యే వరకు queued scans వేచి ఉంటాయి.
  • ENGINE_MAX_WORKERS_PER_SCAN: 0 అయితే aggregate slots scans మధ్య సమానంగా పంచబడతాయి.
  • ENGINE_HARNESS_TIMEOUT_SECONDS: డిఫాల్ట్‌గా 7200. ఒక runaway job కొనసాగగల గరిష్ట సమయం ఇది. Engine 60 నుంచి 86400 వరకు విలువలను అంగీకరిస్తుంది. ఈ పరిధికి బయట ఉన్న ఏ విలువైనా, 0తో సహా, 7200గా పరిగణించబడుతుంది.
  • ENGINE_MIN_FREE_STORAGE_GB: storage floor. ENGINE_IGNORE_LOW_STORAGE=true safeguardను నిలిపివేస్తుంది. దీని వల్ల host disk పూర్తిగా నిండిపోవచ్చని fileలో హెచ్చరిస్తుంది.
  • ENGINE_SCAN_RUNNER_MEMORY_MB: ప్రతి runnerకు hard memory cap. 0 అయితే cap తొలగించబడుతుంది.
  • ENGINE_SCAN_RUNNER_MEMORY_RESERVATION_MB: admission లెక్కలోకి తీసుకునే ప్రతి runnerకు soft reservation. దీన్ని తగ్గిస్తే idle memory overcommit అవుతుంది. అయితే hard cap memory spikesను అదుపులో ఉంచుతుంది.

స్థానిక repositoryని బయటకు పంపకుండా scan చేయడం

LOCAL_REPOS_PATH డిఫాల్ట్‌గా ./local_repos కు సెట్ అవుతుంది. ఇది backend మరియు engine containersలో read-onlyగా bind-mount చేయబడుతుంది. అందువల్ల hostలోని ఆ folderలో ఉంచిన repository వెంటనే containersలో కనిపిస్తుంది. మీ working treeను ఉపయోగించకుండా తాజా cloneను ఉపయోగించండి. Job containerలో మార్చగల copy ఉంటుంది. ఆ containerలో root హక్కులు ఉంటాయి. అలాగే outbound internet access కూడా ఉంటుంది. అందువల్ల ఆ copyలో ఉన్న ఏదైనా మార్చబడవచ్చు లేదా ఈ host వెలుపలికి పంపబడవచ్చు. Projectను copy చేయడానికి ముందు .env files మరియు private keysను తొలగించండి.

మీకు లభించేది, లభించనిది

మీకు ర్యాంక్ చేయబడిన అభ్యర్థి ఫలితాలు లభిస్తాయి. ధృవీకరించబడిన దుర్బలతలు లభించవు. ర్యాంకింగ్ మరియు నకలు తొలగింపు మీ triage queue క్రమాన్ని నిర్ణయిస్తాయి. ఒక entry నిజమైనదని అవి నిరూపించవు. post-scripts validation ప్రయత్నించి proof of concept రూపొందించగలవు. అయితే ఇది tool అందించే అత్యంత బలమైన సంకేతం. post-script విఫలమైతే, ఆ finding తప్పు అని దానికి అర్థం కాదు. ప్రతి అభ్యర్థిని ఒక వ్యక్తి ఇంకా పరిశీలించాలి. అభ్యర్థి మరియు proof మధ్య ఉన్న ఈ వ్యత్యాసం వల్ల మీరే మళ్లీ అమలు చేయగల evidence కోసం agent ను అడగడం ఇక్కడ కూడా ఉపయోగకరంగా ఉంటుంది: మీరు అవసరమైనప్పుడు పునరుత్పత్తి చేయగల finding, నమ్మకంతో స్వీకరించాల్సిన ranked finding కంటే విలువైనది.

open-kritt ఎన్ని నిజమైన bugs ను కనుగొంటుందనే విషయంపై ఈ guide ఎలాంటి హామీ ఇవ్వదు, ఎందుకంటే మేము దాన్ని కొలవలేదు. మీ codebase కోసం detection rate ను ఎవరు ఉటంకించినా, వారు దాన్ని మీ codebase పై అమలు చేయలేదు. ముందుగా మీకు బాగా తెలిసిన repository ను scan చేయండి: మీరే అంచనా వేయగల findings చవకైన calibration మార్గం.

ఇక్కడ authorization కు, చాలా self-hosted tools కంటే ఎక్కువ ప్రాధాన్యత ఉంది. agents code ను compile చేసి execute చేస్తాయి మరియు network ను చేరుకుంటాయి. అందువల్ల proof-of-concept దశ live systems ను తాకవచ్చు. మీరు స్వంతం చేసుకున్న లేదా పరీక్షించడానికి ఒప్పందం చేసుకున్న code పై మాత్రమే దీన్ని అమలు చేయండి. ఏదైనా అమలు చేయడానికి ముందు target scope ను రాతపూర్వకంగా నమోదు చేయండి. మీరు ANTHROPIC_API_KEY ను configure చేసి Claude Code engine ను ఉపయోగిస్తే, VPS పై Claude Code ను సురక్షితంగా అమలు చేయడం లోని sandboxing అలవాట్లు ఈ agents కు కూడా వర్తిస్తాయి.

FAQ

open-kritt కు స్వంత VPS ఎందుకు అవసరం?

దాని analysis agents disposable job containers లో root గా నడుస్తాయి. ఆ containers లో మీ code యొక్క writable copies ఉంటాయి. వాటికి direct internet access కూడా ఉంటుంది. అదనంగా, engine service host Docker socket ను mount చేస్తుంది, తద్వారా ప్రతి job కోసం ఒక container ను ప్రారంభించగలదు. ఆ socket ను చేరుకోగల ఏ process అయినా host filesystem ను mount చేసే container ను ప్రారంభించగలదు. అందువల్ల మొత్తం stack ను దాని host పై root access ఉన్నదిగా పరిగణించాలి. Dedicated VPS లో ఇది ఆమోదయోగ్యమైన trade-off. ఆ machine ను మళ్లీ నిర్మించడం వల్ల మీకు అదనపు నష్టం ఉండదు. అయితే, మీరు రోజువారీగా ఉపయోగించే workstation లో scan చేస్తున్న code కు మీ SSH keys మరియు browser profiles కూడా అదే trust boundary లోకి వస్తాయి.

SSH tunnel ఉపయోగించకుండా port 5173 ను expose చేయవచ్చా?

చేయకూడదు. Backend లో application authentication లేకుండానే release అవుతుంది. అందువల్ల internet మరియు మీ findings, provider credit మధ్య ఉన్న ఏకైక అడ్డంకి ఆ port మాత్రమే. ఆ కారణంగానే compose file ప్రతి service ను 127.0.0.1 కు bind చేస్తుంది. బదులుగా ssh -N -L 5173:127.0.0.1:5173 you@your-server-ip ను run చేసి, స్థానికంగా http://localhost:5173 కు browse చేయండి. ufw rule ప్రత్యామ్నాయం కాదు. ఎందుకంటే published Docker port, ufw యొక్క default policy వర్తించే ముందు handle అవుతుంది.

నేను ప్రణాళిక చేసిన దానికంటే ఎక్కువ ఖర్చు చేయకుండా open-kritt ను ఎలా ఆపాలి?

మొదటి scan కు ముందు మీ model provider console లో hard limit సెట్ చేయండి. open-kritt కు స్వంత budget setting లేదు. మొదటి కొన్ని runs కోసం విడుదలతో వచ్చిన concurrency defaults అయిన ENGINE_WORKER_COUNT=2 మరియు ENGINE_MAX_CONCURRENT_SCANS=1 ను అలాగే ఉంచండి. ఒక provider account ద్వారా default గా గరిష్ఠంగా 15 concurrent root model calls నడపవచ్చని గుర్తుంచుకోండి. ఒక Codex session గరిష్ఠంగా five child agents ను కూడా నడపవచ్చు. ENGINE_WORKER_COUNT=0 ను ఉపయోగిస్తే కొత్త jobs ను తీసుకోవడం pause అవుతుంది. స్థానికంగా ఆపడానికి ఇది వేగవంతమైన మార్గం.

ఏ version ను check out చేయాలి?

main కాదు, ఒక tag ను ఉపయోగించాలి. అందుబాటులో ఉన్న వాటిని git fetch --tags తరువాత git tag --list ద్వారా చూడవచ్చు. 16 August 2026 న ప్రచురించబడిన v1.4.1, 12 October 2026 నాటికి తాజా version. Pinning వల్ల నెలల తరువాత rebuild చేసినా అదే stack వస్తుంది. అలాగే వేరే రోజున clone చేసినప్పుడు అనుకోకుండా upgrade జరగదు. Release notes చదివిన తరువాత upgrade చేయాలా వద్దా అనే నిర్ణయం తీసుకోవచ్చు.

Scan ఎప్పుడూ ప్రారంభం కావడం లేదు. ఏమి పరిశీలించాలి?

ముందుగా free disk space ను పరిశీలించండి. Free storage ENGINE_MIN_FREE_STORAGE_GB కంటే తక్కువగా ఉంటే engine ప్రతి job కోసం scan container ను ప్రారంభించదు. దీని default విలువ 20 GB. తరువాత ENGINE_WORKER_COUNT విలువ 0 కాదని నిర్ధారించండి. ఆ విలువ కొత్త jobs ను తీసుకోవడాన్ని pause చేస్తుంది. తరువాత ./kritt setup ను run చేసి model credential నిజంగా configure అయిందో నిర్ధారించండి. GITHUB_TOKEN ఒక్కటే ఉంటే scans నడపలేరు. Job ను ఎందుకు skip చేసిందో docker compose logs engine చూపిస్తుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?