ఇది ఎలా పనిచేస్తుంది

RADAR ఎలా పనిచేస్తుంది.

డెవలపర్ల కోసం ఒక సాంకేతిక అవలోకనం. RADAR కోడింగ్ ఏజెంట్లను నడుపుతుంది; ఒక పని అంగీకార పరీక్షను తానే మళ్లీ నడిపిన తర్వాతే ఆ పనిని మూసివేస్తుంది. ఏజెంట్ చెప్పే “అయిపోయింది” ఒక క్లెయిమ్; మళ్లీ నడపడమే రుజువు.

01 లూప్

ప్రతి పనికీ ఒకటే లూప్.

ప్రతి పనీ అదే లూప్‌లో తిరుగుతుంది; ముందరి దశ పాసైతేనే ప్రతి దశా నడుస్తుంది.

01 · తెరవడం పని, అంగీకార పరీక్ష పని మొదలవ్వక ముందే రాయబడుతుంది
02 · లీజ్ ఒకే యజమాని, సొంత worktree Lease, fence token
03 · పని ఏజెంట్ పని చేస్తుంది ప్రాజెక్ట్‌కు చెందిన తన సొంత కాపీలో
04 · క్లెయిమ్ అయిపోయిందని ఏజెంట్ చెబుతుంది ఫలితంగా కాకుండా, క్లెయిమ్‌గా నమోదవుతుంది
05 · తనిఖీ RADAR పరీక్షను మళ్లీ నడుపుతుంది ప్రస్తుత రివిజన్‌పై
పాసైతే మూసివేయబడింది రుజువు లెడ్జర్‌లో భద్రపరచబడుతుంది
ఫెయిలైతే · 3లో n వ ప్రయత్నం మళ్లీ తెరవబడింది, వైఫల్యం జతచేయబడింది అదే ఏజెంట్ దశ 03 నుంచి మళ్లీ ప్రయత్నిస్తుంది
3 ప్రయత్నాల తర్వాత మరో ఏజెంట్ బాధ్యత తీసుకుంటుంది దశ 03 నుంచి గరిష్ఠంగా మరో 3 ప్రయత్నాలు
మరో 3 తర్వాత పని మీ కోసం వేచి ఉంటుంది లెడ్జర్ ఇక ప్రయత్నాలను నిరాకరిస్తుంది

చిత్రం 1 · పని లూప్. క్లెయిమ్ మళ్లీ నడపడానికి దారి తీస్తుంది, నేరుగా మూసివేతకు ఎప్పుడూ కాదు.

తెరవడం: ఒక పని దాని లక్ష్యంతో, మళ్లీ నడపగలిగే ఒక అంగీకార కమాండ్‌తో తెరవబడుతుంది. పని తెరిచినప్పుడే కమాండ్ తనిఖీ చేయబడుతుంది, నడపకుండానే: రాసిన విధంగా నడవలేని ప్రమాణం అప్పుడే తిరస్కరించబడుతుంది, చివర్లో బయటపడదు.
లీజ్: ఒక సమయంలో ఒక పని ఒకే యజమాని చేతిలో ఉంటుంది, ఒక lease, ఒక fence token ద్వారా. పాత యజమాని నుంచి వచ్చే రైట్ తిరస్కరించబడుతుంది.
పని: ఏజెంట్ తన సొంత git worktreeలో, తన సొంత branchపై పనిచేస్తుంది.
క్లెయిమ్: పని అయిపోయిందన్న ఏజెంట్ నివేదిక ఒక క్లెయిమ్‌గా నమోదవుతుంది. క్లెయిమ్ పనిని మూసివేయదు.
తనిఖీ: RADAR అంగీకార కమాండ్‌ను తానే నడుపుతుంది, పని యొక్క ప్రస్తుత రివిజన్‌పై. ఏజెంట్ సొంత నివేదిక చదవబడుతుంది, కానీ అది రుజువు కాదు.
మూసివేయడం లేదా మళ్లీ తెరవడం: పాసైతే పనిని మూసివేయవచ్చు, తనిఖీ రికార్డు దాని రుజువుగా భద్రపరచబడుతుంది. ఫెయిలైతే వైఫల్యం జతచేసి పని మళ్లీ తెరవబడుతుంది.
పరిమితులు: మూడు వర్కర్ ప్రయత్నాలు, ఆ తర్వాత మరో ఏజెంట్ చేసే మూడు టేకోవర్లు. ఆ తర్వాత లెడ్జర్ ఇక ప్రయత్నాలను నిరాకరిస్తుంది, పని మీ కోసం వేచి ఉంటుంది. మోడల్, సెషన్ లేదా యంత్రం మార్చినా లెక్క రీసెట్ కాదు; ప్రతి మళ్లీ ప్రయత్నం ఏమి మారిందో చెప్పాలి.

02 లెడ్జర్

ప్రతి ఏజెంట్ రాసే ఒకే రికార్డు.

ప్రతి ఏజెంట్ అదే పని లెడ్జర్‌ను చదువుతుంది, అందులో రాస్తుంది: ఒక లోకల్ SQLite ఫైల్. ప్రతి పని ఎవరి చేతిలో ఉంది, ఏమి క్లెయిమ్ చేయబడింది, పరీక్ష ఏమి చూపింది అనేదానికి ఇదే ఏకైక రికార్డు.

పనులు: లక్ష్యం, అంగీకార కమాండ్, పని మొదలవ్వక ముందే రాయబడినవి.
యాజమాన్యం: ప్రతి పనికీ ప్రస్తుత యజమాని, దాని lease, fence tokenతో సహా.
ప్రయత్నాలు: ప్రతి పనికీ లెక్కించబడతాయి, ఏజెంట్లు, మోడళ్లు, యంత్రాలు అన్నింటినీ కలిపి.
క్లెయిమ్‌లు: పని అయిపోయిందన్న ఏజెంట్ నివేదిక, ఫలితాల నుంచి వేరుగా ఉంచబడుతుంది.
తనిఖీ రికార్డులు: ప్రతి అంగీకార రన్, అది నడిచిన commitకు, working treeకు కట్టుబడి ఉంటుంది.
మార్పులు: అంగీకార కమాండ్ మారితే పాత, కొత్త వెర్షన్లు రెండూ నమోదవుతాయి; override కూడా నమోదవుతుంది.

క్లెయిమ్ ఎందుకు మూసివేత కాదు

పనిని మూసివేయడం పాసైన తనిఖీ రికార్డుపై ఆధారపడుతుంది, రుజువుగా రాసిన ఒక వాక్యంపై కాదు. రికార్డు, నడిచిన commitను, ట్రాక్ చేయబడిన working tree యొక్క digestను పేర్కొంటుంది. రన్ తర్వాత వీటిలో ఏదైనా మారితే, ఉదాహరణకు పరీక్ష పాసైన తర్వాత ఒక ఫైల్ ఎడిట్ చేయబడితే, తనిఖీ మళ్లీ నడిచే వరకు మూసివేత తిరస్కరించబడుతుంది. ఒక వ్యక్తి గేట్‌ను override చేయవచ్చు; ఆ override కూడా నమోదవుతుంది.

జ్ఞాపకం

నిర్ణయాలు, పాఠాలు ఒక మూలం, ఒక పరిధి ఉన్న Markdown నోట్లు. ఒక లోకల్ ఇండెక్స్ వాటిని ఆఫ్‌లైన్‌లో వెతుకుతుంది; ఏజెంట్ పని మొదలుపెట్టే ముందు ఒక hook సరిపోలే నోట్లను దాని ముందు ఉంచుతుంది. నోట్లు సాధారణ Markdown కాబట్టి, మీరు వాటిని Obsidianలో తెరవవచ్చు.

03 ఐసోలేషన్

ప్రతి ప్రయత్నం దాని సొంత కాపీలో.

ప్రతి ప్రయత్నం తన సొంత git worktreeలో, తన సొంత branchపై పనిచేస్తుంది. ఇద్దరు వర్కర్లు ఎప్పుడూ ఒకే treeను పంచుకోరు.
ఒక వర్కర్ తన సొంత అంగీకార కమాండ్‌ను తిరగరాయలేదు. మేనేజర్ మాత్రమే దాన్ని మార్చగలదు, అది కూడా పని మూసివేయడానికి ముందే; ప్రతి మార్పులో పాత, కొత్త వెర్షన్లు రెండూ భద్రపరచబడతాయి.
తనిఖీ పాసైన తర్వాతే పని మీ main branchకు చేరుతుంది, merge తర్వాత అంగీకార కమాండ్ మరోసారి నడుస్తుంది.
ప్రతి పాత్రకూ force-pushలు తిరస్కరించబడతాయి.
ఈ నియమాలు కోడ్‌గా నడుస్తాయి, మోడల్‌ను పిలిచే ముందూ తర్వాతా. ఇవి prompt కాదు, కాబట్టి ఏ ఏజెంట్ మాటలతో వీటిని దాటలేదు.

04 ఏజెంట్లు

మీరు ఇప్పటికే వాడుతున్న ఏజెంట్లు.

RADAR, Claude Code, Codex CLI, OMP, Hermes Agentలను మీ కంప్యూటర్‌లో లేదా మీ సొంత Linux సర్వర్లలో నడుపుతుంది. అది వాటి స్థానాన్ని భర్తీ చేయదు: పని చేసేది ఇప్పటికీ అవే.

Claude Code
Codex CLI
OMP
Hermes Agent

ఒకే ఒప్పందం: అవే నియమాలు, అదే లెడ్జర్, అదే తనిఖీ గేట్, అవే ప్రయత్న పరిమితులు నాలుగింటికీ వర్తిస్తాయి.
మేనేజర్: మీరు మాట్లాడే ఏజెంటే నిర్వహిస్తుంది: పనులు తెరుస్తుంది, వాటిని వర్కర్లకు అప్పగిస్తుంది, పాసైన తనిఖీ రికార్డు ఉంటేనే పనిని మూసివేస్తుంది.
వర్కర్లు: వర్కర్లు తమ సొంత worktreeలలో పని చేస్తాయి. అవి పనులను మూసివేయలేవు, తమ అంగీకార కమాండ్‌ను మార్చలేవు.

05 లోకల్ ఫస్ట్

లోకల్ ఫస్ట్.

RADARకు ఖాతా గానీ క్లౌడ్ గానీ అవసరం లేదు.

మీ యంత్రంపై: లెడ్జర్, జ్ఞాపక నోట్లు, worktreeలు, ప్రతి తనిఖీ రన్, మీ కంప్యూటర్‌లో లేదా మీ సొంత Linux సర్వర్లలో.
నెట్‌వర్క్ అవసరం: మీ ఏజెంట్లకు; అవి ఈరోజు లాగే తమ సొంత ప్రొవైడర్లతో మాట్లాడతాయి. మిగతా ప్రతి బయటి సేవా ఐచ్ఛికమే, మీరు ఆన్ చేసే వరకు ఆఫ్‌లోనే ఉంటుంది.
అవసరాలు: Windows లేదా Linux (macOSకు ఇంకా మద్దతు లేదు), Python 3.12 లేదా అంతకంటే కొత్త వెర్షన్, Git. RADAR Python స్టాండర్డ్ లైబ్రరీని మాత్రమే వాడుతుంది.
ఖర్చు: దీనికంటూ సొంత బిల్లు లేదు. మీరు ఏజెంట్లలో సైన్ ఇన్ చేసిన ఖాతాలనే అవి వాడుతూనే ఉంటాయి. మీరు ప్రొవైడర్‌నూ, ఒక బడ్జెట్‌నూ పేర్కొంటేనే చెల్లింపు API వాడబడుతుంది.
ఇన్‌స్టాల్: మీ కోడింగ్ ఏజెంట్‌కు రిపాజిటరీ లింక్ ఇచ్చి “దీన్ని ఇన్‌స్టాల్ చెయ్యి” అని చెప్పండి. అది మీ కంప్యూటర్‌ను తనిఖీ చేస్తుంది, లేనిదేదైనా ఇన్‌స్టాల్ చేసే ముందు అడుగుతుంది, RADARను ఒక virtual environmentలో ఇన్‌స్టాల్ చేస్తుంది, radar init, radar doctor ఏమి చెబుతున్నాయో తెలియజేస్తుంది.

06 కమాండ్లు

కమాండ్ల చిన్న జాబితా.

మీరు మొదట ఉపయోగించే కమాండ్లు. ప్లేస్‌హోల్డర్లు కోణ బ్రాకెట్లలో ఉంటాయి.

కమాండ్	ఇది ఏమి చేస్తుంది
`radar init`	RADAR హోమ్‌ను, లెడ్జర్‌ను సెటప్ చేస్తుంది.
`radar doctor`	ఇన్‌స్టాల్‌ను తనిఖీ చేసి, ఇంకా కాన్ఫిగర్ చేయని ఐచ్ఛిక సేవలను జాబితా చేస్తుంది.
`radar task new --project P --goal "…" --accept "<command>"`	అంగీకార కమాండ్‌తో ఒక పనిని తెరుస్తుంది.
`radar dispatch <task>`	ఒక పనిని ఏజెంట్‌కు అప్పగిస్తుంది; అది తన సొంత worktreeలో పనిచేస్తుంది.
`radar status`	మొత్తం వ్యవస్థను చూపిస్తుంది.
`radar verify <task>`	ప్రస్తుత రివిజన్‌పై అంగీకార కమాండ్‌ను మళ్లీ నడుపుతుంది.
`radar task done <task> --evidence "<verification report>"`	ఒక పనిని మూసివేస్తుంది. తనిఖీ పాసయ్యే వరకు తిరస్కరించబడుతుంది.
`radar collect`	పూర్తయిన పనిని సేకరిస్తుంది.
`radar integrate`	తనిఖీ చేసిన పనిని mainలోకి merge చేస్తుంది.
`radar stop`	పనిని నిలిపి ఉంచి STOP సెట్ చేస్తుంది.
`radar go`	STOPను తొలగించి, కొనసాగించగలిగే వాటిని జాబితా చేస్తుంది.
`radar memory search --local "<words>"`	జ్ఞాపక నోట్లను ఆఫ్‌లైన్‌లో వెతుకుతుంది.
`radar uiradar web`	టెర్మినల్‌లో లేదా బ్రౌజర్‌లో కాక్‌పిట్‌ను తెరుస్తుంది.
`radar help --all`	ప్రతి కమాండ్‌నూ జాబితా చేస్తుంది. radar <command> -h వివరాలు ఇస్తుంది.

07 ఇది ఏమి చేయదు

RADAR ఏమి చేయదు.

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

08 స్థితి

ముందస్తు యాక్సెస్‌లో ఉంది

ఇప్పుడు ముందస్తు యాక్సెస్. పబ్లిక్ విడుదల సమయంలో ఓపెన్ సోర్స్.

RADAR ముందస్తు యాక్సెస్‌లో ఉంది. పబ్లిక్ విడుదల సమయంలో ఇది Apache-2.0 లైసెన్స్ కింద ఓపెన్ సోర్స్‌గా ప్రచురించబడుతుంది. చేరడానికి మాకు రాయండి.

ముందస్తు యాక్సెస్‌లో చేరండి RADARకు తిరిగి వెళ్లండి