Loop engineering అంటే ఏమిటి? పూర్తి వివరణ

Loop engineering అంటే ఏమిటి

Loop engineering అనేది AI agent నడిచే పునరావృత చక్రాన్ని రూపొందించే పద్ధతి: ఏది దాన్ని మేల్కొల్పుతుంది, అది దేనిని తాకగలదు, దాని అవుట్‌పుట్ ఎలా తనిఖీ చేయబడుతుంది మరియు దేనితో అది ఆగిపోతుంది అనే అంశాలను ఇది నిర్ణయిస్తుంది. Prompt engineering ఒక సందేశాన్ని మోడల్‌కు అనుగుణంగా మారుస్తుంది. Loop engineering మీరు నిద్రిస్తున్నప్పుడు వేలకొద్దీ సందేశాలను పంపే ప్రక్రియను రూపొందిస్తుంది. ఇక్కడ పని యొక్క ప్రాథమిక యూనిట్ prompt నుండి loop కు మారుతుంది.

క్లుప్తంగా చెప్పాలంటే: మీరు సూచనలు రాయడం ఆపివేసి, ఒక కంట్రోల్ సిస్టమ్‌ను రాయడం ప్రారంభిస్తారు. ఏజెంట్‌కు ఇప్పటికీ మంచి సూచనలు అవసరం, కానీ అవి ఒక చక్రంలో భాగంగా మారతాయి. ఈ చక్రం నిర్ణీత సమయానికి నడుస్తుంది, మీ కోడ్ యొక్క ఐసోలేటెడ్ కాపీలో పనిచేస్తుంది, తన ఫలితాన్ని పరీక్ష ద్వారా నిరూపించుకుంటుంది మరియు బడ్జెట్ అయిపోయినప్పుడు ఆగిపోతుంది.

2026లో ఈ పదం ఎందుకు ఉద్భవించింది

ప్రస్తుతం ఈ పేరు బహిరంగంగా స్థిరపడుతోంది. GitHub రిపోజిటరీ cobusgreyling/loop-engineering, మొదటిసారి కనిపించిన రెండు నెలల్లోనే (జూలై 2026 నాటికి) 9,600 స్టార్లను దాటింది. ఇది "Stop prompting. Design the loop. Get a score." అనే నినాదంతో మొదలైంది. ఇది ఈ మార్పును ఆరు ప్రధానాంశాలుగా విభజించింది: షెడ్యూలింగ్ (scheduling), వర్క్‌ట్రీలు (worktrees), నైపుణ్యాలు (skills), ప్లగిన్‌లు మరియు కనెక్టర్లు (plugins and connectors), సబ్-ఏజెంట్లు (sub-agents), మరియు సంభాషణ వెలుపల భద్రపరిచే మన్నికైన మెమరీ (durable memory).

ఇది Anthropic లో Claude Code కు నాయకత్వం వహిస్తున్న Boris Cherny మాటలను ఉటంకిస్తుంది:

నేను ఇకపై Claude ను ప్రాంప్ట్ చేయను. Claude ను ప్రాంప్ట్ చేసే లూప్‌లు (loops) నా దగ్గర నడుస్తున్నాయి.

రెండవ రిపోజిటరీ, AI-Builder-Club/skills, 1,100 స్టార్ల దగ్గర ఉంది (జూలై 2026 నాటికి). ఇది రెండు పాత్రలను నేరుగా పేర్కొంటుంది: ఏజెంట్ పరీక్షలు మరియు డిప్లాయ్‌మెంట్లను సురక్షితంగా నిర్వహించడానికి రిపోజిటరీని సిద్ధం చేసే "codebase harness", మరియు ఒక ట్రిగ్గర్ ద్వారా మేల్కొని, పనిని పూర్తి చేసి, తదుపరి లూప్ చదవడానికి వీలుగా తాను నేర్చుకున్న విషయాన్ని ఒక షేర్డ్ ఫైల్‌లో రాసే "loop engineer".

ఈ రెండు రిపోజిటరీలు ఈ పద్ధతిని కనిపెట్టలేదు. నైట్లీ బిల్డ్ (nightly build), కంటిన్యూయస్ ఇంటిగ్రేషన్‌లో లీంటర్ (linter), లేదా టికెట్‌ను ఓపెన్ చేసే క్రోన్ జాబ్ (cron job) నడిపిన ఎవరికైనా ఈ విధానం ఇప్పటికే తెలుసు. కొత్త విషయం ఏమిటంటే, లూప్ లోపల ఉన్న వర్కర్ ఇప్పుడు నాన్-డిటర్మినిస్టిక్ (non-deterministic) గా పనిచేస్తుంది, దీనివల్ల దాని చుట్టూ ఉన్న మెషినరీ చేయాల్సిన పనులలో మార్పులు వస్తాయి.

లూప్‌లోని నాలుగు భాగాలు

ప్రతి పని చేసే లూప్‌లో ఈ నాలుగు భాగాలు ఉంటాయి. వీటిలో ఏ ఒక్కటి లేకపోయినా, ఆ లూప్ మిమ్మల్ని అర్ధరాత్రి 3 గంటలకు నిద్రలేపే అవకాశం ఉంది.

• Trigger. రన్ ప్రారంభమయ్యే సంఘటన: ఇది ఒక టైమర్, వెబ్‌హుక్ (webhook), కొత్త పుల్ రిక్వెస్ట్ (pull request) లేదా అలర్ట్ కావచ్చు.
• Boundary. రన్ సమయంలో ఏజెంట్ యాక్సెస్ చేయగల ఫైళ్లు, క్రెడెన్షియల్స్ మరియు నెట్‌వర్క్ పరిధి.
• Verification. రన్ అవుట్‌పుట్‌ను ఉంచాలా లేదా తొలగించాలా అని నిర్ణయించే ఎగ్జిట్ కోడ్ (exit code) తో కూడిన తనిఖీ.
• Budget. రన్ విజయవంతమైనా లేదా విఫలమైనా, దానిని ముగించే టోకెన్, సమయం మరియు ఖర్చు పరిమితి.

ఈ నాలుగు భాగాలను ప్రశ్నలుగా మార్చి చూస్తే, మీరు రన్ చేయడానికి సిద్ధంగా ఉన్న ఏ ఏజెంట్ కైనా డిజైన్ రివ్యూ సిద్ధమవుతుంది.

ట్రిగ్గర్: ఏజెంట్‌ను ఏది మేల్కొల్పుతుంది

టైమర్ అనేది అత్యంత సరళమైన ట్రిగ్గర్. Linux సర్వర్‌లో cron కంటే systemd టైమర్ మెరుగైనది, ఎందుకంటే ఇది లాగ్‌లను నమోదు చేస్తుంది, మీరు నిర్ణయించిన నిబంధనల ప్రకారం మళ్లీ ప్రయత్నిస్తుంది మరియు ఇప్పటికే నడుస్తున్న unit యొక్క రెండవ కాపీని ప్రారంభించదు. ఈ చివరి లక్షణం ఏజెంట్ లూప్‌లలో సాధారణంగా కనిపించే ఓవర్‌ల్యాప్ బగ్‌ను తొలగిస్తుంది: అంటే ఒకే బ్రాంచ్‌ను రెండు రన్‌లు ఒకేసారి ఎడిట్ చేయడం జరగదు.

/etc/systemd/system/agent-loop.service వద్ద unit ను ఇలా రాయండి:

[Unit]
Description=Agent loop: triage open issues
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
User=agent
WorkingDirectory=/srv/agent/repo
ExecStart=/srv/agent/bin/loop.sh
TimeoutStartSec=1800

మరియు /etc/systemd/system/agent-loop.timer వద్ద టైమర్‌ను ఇలా రాయండి:

[Unit]
Description=Run the triage loop every 30 minutes

[Timer]
OnBootSec=5min
OnUnitActiveSec=30min
Unit=agent-loop.service

[Install]
WantedBy=timers.target

sudo systemctl daemon-reload
sudo systemctl enable --now agent-loop.timer
systemctl list-timers agent-loop.timer

systemctl list-timers కమాండ్ భవిష్యత్తులో సమయాన్ని చూపే NEXT కాలమ్‌ను మరియు కౌంట్‌డౌన్ చూపే LEFT కాలమ్‌ను చూపాలి. ఫలితం ఖాళీగా ఉంటే, టైమర్ ఎనేబుల్ కాలేదని అర్థం, ఎందుకంటే --now లేకుండా enable వాడితే అది తదుపరి బూట్ కోసం మాత్రమే షెడ్యూల్ అవుతుంది. TimeoutStartSec=1800 అనేది కనిపించే దానికంటే చాలా ముఖ్యమైనది: ఇన్‌పుట్ కోసం వేచి ఉండి హ్యాంగ్ అయిన ఏజెంట్ unit ను ఎప్పటికీ యాక్టివ్‌గా ఉంచుతుంది, దీనివల్ల టైమర్ మళ్లీ ఎప్పటికీ ఫైర్ అవ్వదు. journalctl -u agent-loop.service -n 50 తో రన్‌ను చదవండి.

ఒకవేళ మీరు లూప్‌ను cron ద్వారా నడిపితే, మీ స్వంత ఓవర్‌ల్యాప్ గార్డ్‌ను జోడించండి, ఎందుకంటే cron రెండవ కాపీని సంతోషంగా ప్రారంభిస్తుంది:

*/30 * * * * /usr/bin/flock -n /tmp/agent-loop.lock /srv/agent/bin/loop.sh

flock -n లాక్ ఉన్నప్పుడు వెంటనే 1 స్టేటస్‌తో నిష్క్రమిస్తుంది, కాబట్టి రెండవ రన్ మొదటి దానితో పోటీ పడకుండా నిశ్శబ్దంగా ముగిసిపోతుంది. ఇదే systemd service and timer setup బాక్స్‌లో నడిచే ఏ ఇతర సుదీర్ఘమైన జాబ్‌కైనా వర్తిస్తుంది, అది ఏజెంట్ అయినా కాకపోయినా.

పరిమితి: ప్రతి రన్‌కు దాని స్వంత కాపీని కేటాయించండి

మీ వర్కింగ్ ట్రీని ఎడిట్ చేసే ఏజెంట్, మీరు సేవ్ చేయని (uncommitted) పనిని కోల్పోయేలా చేసే అవకాశం ఉంది. Git worktrees ఈ సమస్యను తక్కువ ఖర్చుతో పరిష్కరిస్తాయి: ప్రతి రన్ తన స్వంత డైరెక్టరీని మరియు బ్రాంచ్‌ను కలిగి ఉంటుంది, కానీ అన్నీ ఒకే ఆబ్జెక్ట్ స్టోర్‌ను పంచుకుంటాయి.

cd /srv/agent/repo
git worktree add -b loop/triage-01 /srv/agent/work/triage-01 origin/main
git worktree list

git worktree list ప్రతి ట్రీ యొక్క పాత్, కమిట్ మరియు బ్రాంచ్ వివరాలను ఒక్కో లైన్‌లో ప్రింట్ చేస్తుంది. రన్ పూర్తయినప్పుడు, git worktree remove /srv/agent/work/triage-01 ఆ డైరెక్టరీని తొలగిస్తుంది, మరియు git worktree prune ఏ డైరెక్టరీలు అయితే మాయమయ్యాయో వాటి ఎంట్రీలను క్లియర్ చేస్తుంది. ఈ దశలో పారలల్ లూప్‌లు సురక్షితంగా మారతాయి, ఎందుకంటే రెండు వేర్వేరు డైరెక్టరీలలోని రెండు బ్రాంచ్‌లపై పనిచేసే ఏజెంట్లు ఒకదానిపై ఒకటి ఓవర్‌రైట్ చేసుకోలేవు.

ఈ పరిమితి క్రెడెన్షియల్స్‌కు కూడా వర్తిస్తుంది. పర్యవేక్షణ లేకుండా నడిచే లూప్ దీర్ఘకాలం చెల్లుబాటు అయ్యే టోకెన్లను కలిగి ఉంటుంది, మరియు ప్రతి రన్ ఆ టోకెన్‌ను లాగ్ ఫైల్‌లో, కమిట్‌లో లేదా మోడల్ కాంటెక్స్ట్‌లో లీక్ చేసే అవకాశం కలిగిస్తుంది. లూప్ ఏ రిపోజిటరీతో అయితే పనిచేస్తుందో ఆ రిపోజిటరీకి మాత్రమే టోకెన్ పరిధిని (scope) పరిమితం చేయండి. ఏజెంట్ యొక్క సొంత షెల్ చూసే ఎన్విరాన్‌మెంట్‌లో టోకెన్ లేకుండా చూడండి. లూప్‌కు ప్రొడక్షన్ యాక్సెస్ ఇచ్చే ముందు AI ఏజెంట్ల నుండి రహస్యాలను ఎలా సురక్షితంగా ఉంచాలి అనే అంశాన్ని చదవండి. మరింత కఠినమైన భద్రత కోసం, మొత్తం లూప్‌ను ప్రతి రన్ తర్వాత తొలగించగల disposable VM పై ఉంచండి. మీరు ఏ టూల్‌ను ఉపయోగిస్తున్నారనేది కూడా మీరు కోడ్ రాయకముందే పరిమితిని నిర్ణయిస్తుంది, కాబట్టి మీకు ఎంత ఐసోలేషన్ అవసరమో నిర్ణయించుకునే ముందు Cowork యొక్క మేనేజ్డ్ శాండ్‌బాక్స్ మరియు మీ మెషీన్‌పై నడిచే Claude Code మధ్య వ్యత్యాసాలు గురించి చదవడం మంచిది.

ధృవీకరణ: లూప్‌ను సురక్షితంగా ఉంచే గేట్

ఇది ఒక లూప్‌ను, కేవలం టైప్ చేసే cron job నుండి వేరు చేసే భాగం. ఏజెంట్ ఇచ్చే అవుట్‌పుట్ ఒక ప్రతిపాదన మాత్రమే. గేట్ దానిని నిర్ణయిస్తుంది.

#!/usr/bin/env bash
set -euo pipefail

repo=/srv/agent/repo
branch="loop/$(date -u +%Y%m%dT%H%M%SZ)"
tree="/srv/agent/work/$(basename "$branch")"

cd "$repo"
git fetch --quiet origin
git worktree add -b "$branch" "$tree" origin/main
cd "$tree"

# the agent's own command runs here, in non-interactive mode

if ! npm test; then
  echo "gate failed: discarding $branch" >&2
  cd "$repo"
  git worktree remove --force "$tree"
  exit 1
fi

git push origin "$branch"
cd "$repo"
git worktree remove "$tree"

ఆ స్క్రిప్ట్‌లో set -euo pipefail నిజమైన పనిని చేస్తోంది. -e లేకపోతే, విఫలమైన git fetch పట్టించుకోబడదు మరియు పాత origin/main తో రన్ కొనసాగుతుంది. -u లేకపోతే, వేరియబుల్ పేరులో టైపింగ్ తప్పు ఉంటే అది ఖాళీ స్ట్రింగ్‌గా మారుతుంది, అప్పుడు క్లీనప్ ప్రక్రియ విఫలం కావడానికి బదులుగా తప్పు పాత్‌పై రన్ అవుతుంది.

if ! npm test బ్లాక్ అనేది మొత్తం ఆలోచనకు మూలం. మీరు ఇప్పటికే నమ్మే ఒక చెక్ యొక్క ఎగ్జిట్ కోడ్, అంటే మీ టెస్ట్ సూట్ లేదా టైప్ చెకర్, ఆ బ్రాంచ్ పుష్ చేయాలా లేదా తొలగించాలా అని నిర్ణయిస్తుంది. గేట్ లేని లూప్ ఎవరూ సమీక్షించలేని పనిని సృష్టిస్తుంది, ఇది పని చేయకపోవడం కంటే ప్రమాదకరం. గేట్ ఉన్న లూప్, ఒక మానవ కంట్రిబ్యూటర్ బ్రాంచ్ పాస్ కావాల్సిన ప్రమాణాలనే పాస్ అయిన బ్రాంచ్‌ను సృష్టిస్తుంది. గ్రీన్ గేట్ అనేది ఏజెంట్ ఎంత కోడ్‌ను మార్చిందో చెప్పదు, కాబట్టి దీనిని ఏజెంట్ పని చేసే అతి చిన్న మార్పును మాత్రమే తీసుకునేలా చేసే నియమం వంటి స్థిరమైన సూచనలతో జత చేయడం మంచిది. ఇది డిఫ్ (diff) పరిమాణాన్ని తక్కువగా ఉంచి, సమీక్షను సులభతరం చేస్తుంది.

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

బడ్జెట్: రన్ ఎప్పుడు ఆగిపోతుంది

ఎల్లప్పుడూ ప్రయత్నిస్తూనే ఉండే ఏజెంట్ వల్ల బిల్లు అపరిమితంగా పెరిగిపోతుంది. ప్రతి లూప్‌కు ఒక నిర్ణీత సమయ పరిమితిని విధించండి, దీనిని పైన పేర్కొన్న TimeoutStartSec ద్వారా అమలు చేయవచ్చు; మీ స్క్రిప్ట్‌లో ఒక retry కౌంట్‌ను ఉంచండి; మరియు ప్రొవైడర్ ఖాతాలో ఖర్చుపై ఒక పరిమితిని (spend cap) సెట్ చేయండి. ప్రతి రన్‌కు ఎంత ఖర్చవుతుందో లాగ్ చేయండి, తద్వారా ఇన్‌వాయిస్ రాకముందే లూప్ అదుపు తప్పుతుందో లేదో మీరు గమనించవచ్చు. ఎల్లప్పుడూ ఆన్‌లో ఉండే ఏజెంట్ VPS కోసం ఖర్చు నియంత్రణ అనే విభాగం అకౌంటింగ్ అంశాలను వివరిస్తుంది, మరియు ఏజెంట్ టర్న్‌ల మధ్య ఉంచే కాంటెక్స్ట్‌ను నిర్వహించడం అనే విభాగం ప్రతి రన్ ఖర్చుపై ప్రభావం చూపే అతిపెద్ద అంశాన్ని వివరిస్తుంది. ఎందుకంటే ప్రతి 30 నిమిషాలకు ఒకే రిపోజిటరీని మళ్లీ మళ్లీ చదివే లూప్, ప్రతిసారీ దానికి చెల్లించాల్సి ఉంటుంది.

ఒకే సుదీర్ఘ సెషన్ కంటే లూప్‌లు ఎందుకు మెరుగైనవో చెప్పడానికి ఖర్చే ప్రధాన కారణం. కొత్తగా ప్రారంభమై, ఒక చిన్న పనిని పూర్తి చేసి ఆగిపోయే రన్, తన కాంటెక్స్ట్‌ను తక్కువగా ఉంచుకుంటుంది. ఎనిమిది గంటల పాటు తెరిచి ఉంచిన సెషన్, తన చరిత్రలోని ప్రతి పాత తప్పును మోస్తూ, ప్రతి టర్న్‌లో మొత్తం ట్రాన్స్‌క్రిప్ట్ కోసం చెల్లిస్తుంది.

ట్రెండింగ్‌లో ఉన్న రిపోజిటరీలు క్రోడీకరించే పద్ధతులు

loop-engineering రిపోజిటరీ ఏడు ప్రొడక్షన్ పద్ధతులను జాబితా చేస్తుంది. వీటిని ఒక మేనిఫెస్టోగా కాకుండా, ఒక మెనూగా పరిగణించి చదవడం మంచిది. రోజువారీ ట్రయాజ్ (triage). రివ్యూ కామెంట్లను గమనించి వాటికి సమాధానమిచ్చే పుల్-రిక్వెస్ట్ బేబీసిటర్. విఫలమైన బిల్డ్‌లను గుర్తించే కంటిన్యూయస్-ఇంటిగ్రేషన్ స్వీపర్. డిపెండెన్సీ స్వీపర్. చేంజ్‌లాగ్ డ్రాఫ్టర్. పోస్ట్-మెర్జ్ క్లీనప్. ఇష్యూ ట్రయాజ్.

వీటన్నింటిలోనూ ఒక స్పష్టమైన గేట్ (gate) కలిగిన పరిమితమైన పని ఉంటుంది. "విఫలమైన బిల్డ్‌ను సరిచేయి" అనే దానికి మెషిన్ గుర్తించగలిగే పాస్ కండిషన్ ఉంటుంది. "కోడ్‌బేస్‌ను మెరుగుపరచు" అనే దానికి అటువంటి కండిషన్ ఉండదు, కాబట్టి అది ఎప్పటికీ ఒక లూప్‌గా మారదు. అది కేవలం ఒక షెడ్యూల్ ప్రకారం జరిగే గందరగోళంగా మారుతుంది.

వీటన్నింటిలోనూ ఒక లిఖితపూర్వక రికార్డు ఉంటుంది. రెండు రిపోజిటరీలు కూడా స్థితిని (state) సంభాషణ నుండి బయటకు తీసి, రిపోజిటరీలోని ఫైళ్లలోకి పంపుతాయి: ఏమి రన్ అయింది, ఏమి కనుగొంది, ఏమి నిర్ణయించింది అనేది అందులో ఉంటుంది. ఆ ఫైలే లూప్ యొక్క జ్ఞాపకశక్తి. అందుకే ఒక లూప్ చేసిన పనిని మరొక లూప్ మళ్ళీ మొదటి నుండి కనుగొనకుండా, దానిపై ఆధారపడి నిర్మించగలదు. రన్ ముగిసిన వెంటనే మోడల్ యొక్క కాంటెక్స్ట్ పోతుంది కాబట్టి, జరిగిన పనిని ఆ తర్వాత ఆడిట్ చేయడానికి కూడా ఇదే మార్గం. లైవ్ కోఆర్డినేషన్ అనేది ఒక ప్రత్యేక ఛానెల్. ఒక Claude Code సెషన్ అదే బాక్స్‌లో రన్ అవుతున్న మరొక సెషన్‌కు పనిని అప్పగించగలదు, కానీ ఆ మార్పిడిలో ఏదీ సెషన్ ముగిసిన తర్వాత ఉండదు. కాబట్టి, మీరు తర్వాత తిరిగి చదవగలిగేది ఆ ఫైల్ మాత్రమే.

లూప్‌లు ఎక్కడ విఫలమవుతాయి

ఈ వైఫల్యాలు సాధారణమైనవి మరియు వివిధ టీమ్‌లలో పదేపదే జరుగుతుంటాయి.

• గేట్ లేకపోవడం. అవుట్‌పుట్ పేరుకుపోతుంది, ఎవరూ దానిని సమీక్షించరు, నమ్మకం సన్నగిల్లుతుంది, చివరకు ఆ లూప్‌ను నిలిపివేస్తారు.
• ఓవర్‌ల్యాప్. ఒకే బ్రాంచ్‌పై రెండు రన్‌లు లేదా ఒకే వర్కింగ్ ట్రీలో రెండు ఏజెంట్లు పనిచేయడం వల్ల వైరుధ్యాలు (conflicts) ఏర్పడతాయి, వాటిని పరిష్కరించడానికి ఏజెంట్ ప్రయత్నిస్తుంది.
• సైలెంట్ డ్రిఫ్ట్. చెక్ చాలా బలహీనంగా ఉండటం వల్ల లూప్ పాస్ అవుతూనే ఉంటుంది.
• అపరిమిత పరిధి (Unbounded scope). బిజీగా ఉన్న రిపోజిటరీలో ప్రతి కమిట్‌కు ట్రిగ్గర్ అవ్వడం వల్ల ఒకే రోజులో ఖర్చు సమస్యగా మారుతుంది.

వీటన్నింటికీ ఒకే పరిష్కారం ఉంది: జాబ్‌ను తగ్గించండి, చెక్‌ను మరింత కచ్చితంగా మార్చండి మరియు రన్‌ను లాగ్ చేయండి. ఒకవేళ మీరు పాస్ అయ్యే కండిషన్‌ను ఒక్క వాక్యంలో వివరించలేకపోతే, ఆ జాబ్ ఆటోమేషన్‌కు సిద్ధంగా లేదని అర్థం.

పరిభాష అవసరం లేకుండా ప్రారంభించడం

మీకు ఎటువంటి framework అవసరం లేదు. ఎల్లప్పుడూ ఆన్‌లో ఉండే ఒక చిన్న Linux సర్వర్, పరీక్షలు విఫలమైనప్పుడు తప్పును గుర్తించే ఒక git repository, ఒక systemd timer మరియు ఒక if ఉన్న shell script కలిస్తే ఒక పూర్తి లూప్ తయారవుతుంది. చాలామంది ఇక్కడే ప్రారంభించాలి, ఎందుకంటే ఒక సాధనాన్ని ఎంచుకోవడం కంటే, ఆ పనిని నేరుగా అమలు చేయడం ద్వారానే డిజైన్ పరమైన ప్రశ్నలకు సమాధానాలు దొరుకుతాయి. ఒక లూప్ స్థిరంగా ఉన్న తర్వాత, మరొక లూప్‌ను నడపడం అనేది కేవలం మరొక timer మరియు మరొక worktree ని జోడించడం మాత్రమే. బేస్ సెటప్ కోసం VPS పై coding AI agent ను ఎలా రన్ చేయాలి చూడండి, మరియు మీరు నియంత్రించే హార్డ్‌వేర్‌పైనే agent రన్ అవ్వాలనుకుంటే ప్రస్తుతం అందుబాటులో ఉన్న self-hosted AI agent ఎంపికలు చూడండి.

FAQ

లూప్ ఇంజనీరింగ్ మరియు ప్రాంప్ట్ ఇంజనీరింగ్ వేర్వేరుగా ఉంటాయా?

ప్రాంప్ట్ ఇంజనీరింగ్ ఒకే సందేశాన్ని ఆప్టిమైజ్ చేస్తుంది: పదాల ఎంపిక, ఉదాహరణలు, అవుట్‌పుట్ ఫార్మాట్. లూప్ ఇంజనీరింగ్ ఆ సందేశం చుట్టూ ఉండే చక్రం (cycle) మొత్తాన్ని ఆప్టిమైజ్ చేస్తుంది: రన్‌ను ప్రారంభించే ట్రిగ్గర్, అది నడిచే శాండ్‌బాక్స్, అవుట్‌పుట్‌ను అంగీకరించే లేదా తిరస్కరించే చెక్, మరియు దానిని ముగించే బడ్జెట్. లూప్ లోపల ఇప్పటికీ మంచి ప్రాంప్ట్ అవసరం. కానీ ప్రాంప్ట్ అనేది మీరు రోజువారీగా మార్పులు చేసే అంశంగా ఉండదు, ఎందుకంటే ఫలితంపై గేట్ మరియు ట్రిగ్గర్ ఎక్కువ ప్రభావాన్ని చూపుతాయి.

ఏజెంట్ లూప్‌ను రూపొందించడానికి ఫ్రేమ్‌వర్క్ అవసరమా?

అవసరం లేదు. ఒక systemd టైమర్, ప్రతి రన్‌కు ఒక git worktree, టెస్ట్ కమాండ్‌తో ముగిసే షెల్ స్క్రిప్ట్, మరియు ప్రొవైడర్ అకౌంట్‌పై ఉండే ఖర్చు పరిమితి (spend cap) ఈ నిర్వచనంలోని ప్రతి భాగాన్ని కవర్ చేస్తాయి. ఫ్రేమ్‌వర్క్‌లు షెడ్యూలింగ్ ఇంటర్‌ఫేస్‌లు, షేర్డ్ మెమరీ ఫార్మాట్‌లు మరియు మల్టీ-ఏజెంట్ రూటింగ్‌ను జోడిస్తాయి; ఇవి మీరు అనేక లూప్‌లను నడుపుతున్నప్పుడు ఉపయోగపడతాయి. మొదటి లూప్ కోసం ఇవి ప్రాథమిక అవసరాలు కావు.

కోడ్‌బేస్ హార్నెస్ (codebase harness) అంటే ఏమిటి?

మనిషి ప్రమేయం లేకుండా ఒక ఏజెంట్ రిపోజిటరీలో పనిచేయడానికి వీలు కల్పించే అంశాల సమితి ఇది: ఒకే కమాండ్‌తో సెటప్, ఇంటరాక్టివ్ అవసరం లేకుండా నడిచి, విఫలమైతే స్పష్టంగా తెలియజేసే టెస్టులు, ఒక లీంటర్ (linter), మరియు మార్పును డిప్లాయ్ చేయడానికి లేదా ప్రివ్యూ చేయడానికి ఒక మార్గం. ఈ పదం లూప్ ఇంజనీరింగ్‌తో పాటు 2026 నాటి రిపోజిటరీల తరంగం నుండి వచ్చింది. దీనికి ఆచరణాత్మక పరీక్ష చాలా సులభం: ఒక కొత్త వ్యక్తి క్లోన్ చేసిన తర్వాత ఒకే కమాండ్‌తో టెస్టులను గ్రీన్ (pass) చేయలేకపోతే, ఏజెంట్ కూడా చేయలేదు.

ఏజెంట్ లూప్ భారీ బిల్లును పెంచకుండా ఎలా ఆపాలి?

దీనిని మూడు చోట్ల పరిమితం చేయండి. systemd unit పై TimeoutStartSec సెట్ చేయండి, తద్వారా ఆగిపోయిన (hung) రన్ నిలిపివేయబడుతుంది. సక్సెస్ అయ్యే వరకు లూప్ చేయడం కంటే, స్క్రిప్ట్ లోపలే రీట్రైలను పరిమితం చేయండి. API అకౌంట్‌పై కఠినమైన ఖర్చు పరిమితిని (hard spend limit) సెట్ చేయండి, ఎందుకంటే ఏజెంట్ దాటలేని ఏకైక పరిమితి అదే. ఆపై ప్రతి రన్ ఖర్చును లాగ్ చేయండి, ఎందుకంటే ఖర్చు రెట్టింపు అయ్యే లూప్ అంటే సాధారణంగా దాని పరిధి (scope) నిశ్శబ్దంగా విస్తరించినట్లు అర్థం.

ఏ పనులను మొదట లూప్‌గా మార్చడం మంచిది?

మెషిన్-రీడబుల్ పాస్ కండిషన్ మరియు తక్కువ ప్రభావం (blast radius) ఉన్న పనిని ఎంచుకోండి. రెడ్ బిల్డ్‌ను సరిచేయడం, డిపెండెన్సీని అప్‌డేట్ చేయడం మరియు చేంజ్‌లాగ్‌ను రీజెనరేట్ చేయడం వంటివి దీనికి సరిపోతాయి, ఎందుకంటే టెస్ట్ సూట్ లేదా డిఫ్ (diff) ఫలితాన్ని నిరూపించగలవు. రీఫ్యాక్టరింగ్ లేదా డిజైన్ వంటి అస్పష్టమైన పనులు ఇంకా దీనికి సరిపోవు, ఎందుకంటే గేట్ తనిఖీ చేయడానికి అక్కడ ఏమీ ఉండదు. గేట్ లేని లూప్ అనేది రివ్యూ డెట్‌ను పెంచే ఖరీదైన మార్గం మాత్రమే.