మోడల్ నుండి ఏజెంట్ వరకు: Responses APIకి కంప్యూటర్ ఎన్విరాన్మెంట్ను సమకూర్చడం
బో షు, డ్యానీ జాంగ్, మరియు రోహిత్ అరుణాచలం ద్వారా
ప్రస్తుతం మనం ప్రత్యేక టాస్క్స్లో నైపుణ్యం ఉన్న మోడల్స్ నుంచి, కాంప్లెక్స్ వర్క్ఫ్లోలను హ్యాండిల్ చేయగల ఏజెంట్ల వైపు మారుతున్నాం. మోడల్స్ను ప్రాంప్ట్ చేయడం ద్వారా, మీరు ట్రెయిన్ చేసిన ఇంటెలిజెన్స్కే యాక్సెస్ పొందగలరు. అయితే, మోడల్కు కంప్యూటర్ ఎన్విరాన్మెంట్ ఇవ్వడం ద్వారా, సర్వీసెస్ నడపడం, APIs నుండి డేటా రిక్వెస్ట్ చేయడం, లేదా స్ప్రెడ్షీట్స్ లేదా రిపోర్ట్స్ వంటి మరింత ఉపయోగకరమైన ఆర్టిఫాక్ట్స్ను జనరేట్ చేయడం వంటి విస్తృతమైన యూజ్ కేసులను సాధించవచ్చు.
ఏజెంట్లను నిర్మించడానికి ప్రయత్నించినప్పుడు కొన్ని ప్రాక్టికల్ సమస్యలు వస్తాయి: మధ్యలో వచ్చే ఫైల్స్ను ఎక్కడ ఉంచాలి, పెద్ద టేబుల్స్ను ప్రాంప్ట్లో పేస్ట్ చేయడం ఎలా నివారించాలి, సెక్యూరిటీ సమస్యలు లేకుండా వర్క్ఫ్లోకి నెట్వర్క్ యాక్సెస్ ఎలా ఇవ్వాలి, మరియు స్వయంగా వర్క్ఫ్లో సిస్టమ్ నిర్మించకుండా టైమ్ఔట్స్ మరియు రీట్రైస్ను ఎలా హ్యాండిల్ చేయాలి.
డెవలపర్స్ తమ స్వంత ఎగ్జిక్యూషన్ ఎన్విరాన్మెంట్స్ను నిర్మించాల్సిన బాధ్యత వేయకుండా, రియల్-వరల్డ్ టాస్క్స్ను విశ్వసనీయంగా ఎగ్జిక్యూట్ చేయడానికి Responses API(కొత్త విండోలో తెరుచుకుంటుంది) కి కంప్యూటర్ ఎన్విరాన్మెంట్ను సమకూర్చేందుకు మేము అవసరమైన కంపోనెంట్స్ను నిర్మించాము.
OpenAI యొక్క Responses API, షెల్ టూల్ మరియు హోస్టెడ్ కంటైనర్ వర్క్స్పేస్తో కలిసి, ఈ ప్రాక్టికల్ సమస్యలను పరిష్కరించడానికి రూపొందించబడింది. మోడల్ స్టెప్స్ మరియు కమాండ్స్ను సూచిస్తుంది; ప్లాట్ఫారమ్ వాటిని ఐసోలేటెడ్ ఎన్విరాన్మెంట్లో ఇన్పుట్స్ మరియు అవుట్పుట్స్ కోసం ఫైల్సిస్టమ్, ఐచ్ఛిక స్ట్రక్చర్డ్ స్టోరేజ్ (SQLite వంటి), మరియు పరిమిత నెట్వర్క్ యాక్సెస్తో రన్ చేస్తుంది.
ఈ పోస్ట్లో, ఏజెంట్ల కోసం కంప్యూటర్ ఎన్విరాన్మెంట్ను ఎలా నిర్మించామో వివరంగా చెప్పి, దాన్ని వేగంగా, మరింత రిపీట్ చేయగలిగేలా, మరియు సేఫ్ ప్రొడక్షన్ వర్క్ఫ్లోల కోసం ఎలా ఉపయోగించాలో కొన్ని ప్రారంభ పాఠాలను పంచుకుంటాము.
ఒక మంచి ఏజెంట్ వర్క్ఫ్లో ఒక టైట్ ఎగ్జిక్యూషన్ లూప్తో ప్రారంభమవుతుంది: మోడల్ ఫైల్స్ చదవడం లేదా API ద్వారా డేటా ఫెచ్ చేయడం వంటి యాక్షన్ను సూచిస్తుంది, ప్లాట్ఫారమ్ దాన్ని రన్ చేస్తుంది, మరియు ఫలితం తదుపరి స్టెప్లోకి వెళుతుంది. ఈ లూప్ను యాక్షన్లో చూడడానికి సులభమైన మార్గమైన షెల్ టూల్తో ప్రారంభించి, తరువాత కంటైనర్ వర్క్స్పేస్, నెట్వర్కింగ్, మళ్లీ ఉపయోగించగల స్కిల్స్, మరియు కాంటెక్స్ట్ కంపాక్షన్ గురించి వివరంగా చూస్తాము.
షెల్ టూల్ను అర్థం చేసుకోవాలంటే, ముందుగా లాంగ్వేజ్ మోడల్ టూల్స్ను సాధారణంగా ఎలా ఉపయోగిస్తుందో తెలుసుకోవడం ఉపయోగకరం: ఫంక్షన్ కాల్ చేయడం లేదా కంప్యూటర్తో ఇంటరాక్ట్ అవడం వంటి పనుల కోసం. ట్రైనింగ్ సమయంలో, టూల్స్ ఎలా ఉపయోగించబడతాయో మరియు వాటి ఫలితాలు ఏమిటో స్టెప్ బై స్టెప్గా మోడల్కు చూపిస్తారు. ఇది మోడల్కు ఎప్పుడు టూల్ ఉపయోగించాలో మరియు ఎలా ఉపయోగించాలో నిర్ణయించడం నేర్పిస్తుంది. “టూల్ ఉపయోగించడం” అంటే, మోడల్ వాస్తవానికి టూల్ కాల్ను మాత్రమే ప్రపోజ్ చేస్తుందని అర్థం. అది స్వయంగా ఆ కాల్ను ఎగ్జిక్యూట్ చేయలేడు.
షెల్ టూల్ మోడల్ను గణనీయంగా మరింత శక్తివంతం చేస్తుంది: ఇది కమాండ్ లైన్ ద్వారా కంప్యూటర్తో ఇంటరాక్ట్ అయి, టెక్స్ట్ సెర్చ్ చేయడం నుండి మీ కంప్యూటర్పై API రిక్వెస్ట్స్ పంపడం వరకు విస్తృతమైన టాస్క్స్ను నిర్వహిస్తుంది. పరిచయమైన Unix టూలింగ్పై నిర్మించబడిన మా షెల్ టూల్, మీరు ఆశించే అన్ని పనులను చేయగలదు, ఇందులో grep, curl, మరియు awk వంటి యుటిలిటీస్ అవుట్ ఆఫ్ ది బాక్స్గా అందుబాటులో ఉంటాయి.
Python మాత్రమే ఎగ్జిక్యూట్ చేసే మా ప్రస్తుత కోడ్ ఇంటర్ప్రెటర్తో పోలిస్తే, షెల్ టూల్ చాలా విస్తృతమైన యూజ్ కేసులను ఎనేబుల్ చేస్తుంది, ఉదాహరణకు Go లేదా Java ప్రోగ్రామ్స్ నడపడం లేదా NodeJS సర్వర్ను ప్రారంభించడం. ఈ ఫ్లెక్సిబిలిటీ మోడల్కు కాంప్లెక్స్ ఏజెంటిక్ టాస్క్స్ను పూర్తి చేయడానికి సహాయపడుతుంది.
మోడల్ తనంతట అది షెల్ కమాండ్స్ను మాత్రమే ప్రపోజ్ చేయగలదు, కానీ ఆ కమాండ్స్ ఎలా ఎగ్జిక్యూట్ అవుతాయి? మోడల్ అవుట్పుట్ను తీసుకుని, టూల్స్ను ఇన్వోక్ చేసి, టూల్ రెస్పాన్స్ను మోడల్కు తిరిగి లూప్లో పంపే ఆర్కెస్ట్రేటర్ అవసరం, టాస్క్ పూర్తి అయ్యే వరకు.
Responses API ద్వారా డెవలపర్స్ OpenAI మోడల్స్తో ఇంటరాక్ట్ అవుతారు. కస్టమ్ టూల్స్తో ఉపయోగించినప్పుడు, Responses API కంట్రోల్ను తిరిగి క్లయింట్కి ఇస్తుంది, మరియు టూల్స్ను రన్ చేయడానికి క్లయింట్ తన స్వంత హార్నెస్ అవసరం ఉంటుంది. అయితే, ఈ API మోడల్ మరియు హోస్టెడ్ టూల్స్ మధ్య ఆర్కెస్ట్రేషన్ను అవుట్ ఆఫ్ ది బాక్స్గా కూడా నిర్వహించగలదు.
Responses API ఒక ప్రాంప్ట్ను స్వీకరించినప్పుడు, ఇది మోడల్ కాంటెక్స్ట్ను సేకరిస్తుంది: యూజర్ ప్రాంప్ట్, ముందున్న సంభాషణ స్థితి, మరియు టూల్ ఇన్స్ట్రక్షన్స్. షెల్ ఎగ్జిక్యూషన్ సరిగా పని చేయడానికి, ప్రాంప్ట్లో షెల్ టూల్ను ఉపయోగించాలని పేర్కొనాలి మరియు ఎంచుకున్న మోడల్ షెల్ కమాండ్స్ను ప్రపోజ్ చేయడానికి ట్రెయిన్ చేయబడాలి—GPT‑5.2 మరియు తరువాతి మోడల్స్ ఇందుకు ట్రెయిన్ చేయబడ్డాయి. ఈ మొత్తం కాంటెక్స్ట్తో, మోడల్ తరువాతి యాక్షన్ను నిర్ణయిస్తుంది. ఇది షెల్ ఎగ్జిక్యూషన్ను ఎంచుకుంటే, ఒకటి లేదా ఎక్కువ షెల్ కమాండ్స్ను Responses API సర్వీస్కి పంపుతుంది. API సర్వీస్ ఆ కమాండ్స్ను కంటైనర్ రన్టైమ్కి ఫార్వర్డ్ చేసి, షెల్ అవుట్పుట్ను స్ట్రీమ్ చేసి, తదుపరి రిక్వెస్ట్ కాంటెక్స్ట్లో మోడల్కి అందిస్తుంది. మోడల్ తరువాత ఫలితాలను పరిశీలించి, ఫాలో-అప్ కమాండ్స్ను ఇష్యూ చేయవచ్చు లేదా ఫైనల్ సమాధానం ఇవ్వవచ్చు. అదనపు షెల్ కమాండ్స్ లేకుండా మోడల్ పూర్తి సమాధానం ఇచ్చే వరకు Responses API ఈ లూప్ను పునరావృతం చేస్తుంది.
Responses API ఒక షెల్ కమాండ్ను ఎగ్జిక్యూట్ చేసినప్పుడు, ఇది కంటైనర్ సర్వీస్తో స్ట్రీమింగ్ కనెక్షన్ను కొనసాగిస్తుంది. అవుట్పుట్ ఉత్పత్తి అవుతున్నప్పుడు, API దాన్ని మోడల్కి దాదాపు రియల్ టైమ్లో పంపుతుంది, తద్వారా మోడల్ మరింత అవుట్పుట్ కోసం వేచి ఉండాలా, మరో కమాండ్ రన్ చేయాలా, లేదా ఫైనల్ రెస్పాన్స్కు వెళ్లాలా అని నిర్ణయించగలదు.
Responses API షెల్ కమాండ్ అవుట్పుట్ను స్ట్రీమ్ చేస్తుంది
మోడల్ ఒకే స్టెప్లో అనేక షెల్ కమాండ్స్ను ప్రపోజ్ చేయగలదు, మరియు Responses API వాటిని వేర్వేరు కంటైనర్ సెషన్స్ ఉపయోగించి ఒకేసారి ఎగ్జిక్యూట్ చేయగలదు. ప్రతి సెషన్ స్వతంత్రంగా అవుట్పుట్ను స్ట్రీమ్ చేస్తుంది, మరియు API ఆ స్ట్రీమ్స్ను మళ్లీ స్ట్రక్చర్డ్ టూల్ అవుట్పుట్స్గా కాంటెక్స్ట్లో మల్టీప్లెక్స్ చేస్తుంది. మరొక విధంగా చెప్పాలంటే, ఏజెంట్ లూప్ ఫైల్స్ సెర్చ్ చేయడం, డేటా ఫెచ్ చేయడం, మరియు మధ్యంతర ఫలితాలను వాలిడేట్ చేయడం వంటి పనులను ప్యారలలైజ్ చేయగలదు.
కమాండ్లో ఫైల్ ఆపరేషన్స్ లేదా డేటా ప్రాసెసింగ్ ఉంటే, షెల్ అవుట్పుట్ చాలా పెద్దదిగా మారి, ఉపయోగకరమైన సిగ్నల్స్ ఇవ్వకుండా కాంటెక్స్ట్ బడ్జెట్ను ఖర్చు చేయవచ్చు. దీనిని నియంత్రించడానికి, మోడల్ ప్రతి కమాండ్కు అవుట్పుట్ క్యాప్ను నిర్ధేశిస్తుంది. Responses API ఆ క్యాప్ను అమలు చేసి, అవుట్పుట్ ప్రారంభం మరియు ముగింపు భాగాలను కాపాడుతూ, మధ్యలో తొలగించిన కంటెంట్ను సూచిస్తూ ఒక పరిమిత ఫలితాన్ని ఇస్తుంది. ఉదాహరణకు, మీరు అవుట్పుట్ను 1,000 క్యారెక్టర్స్కు పరిమితం చేసి, ప్రారంభం మరియు ముగింపు భాగాలను కాపాడవచ్చు:
ప్రారంభంలో ఉన్న టెక్స్ట్ ... 1000 క్యారెక్టర్స్ ట్రంకేట్ చేయబడ్డాయి ... చివరలో ఉన్న టెక్స్ట్
కలిసి, కాంకరెంట్ ఎగ్జిక్యూషన్ మరియు బౌండెడ్ అవుట్పుట్ ఏజెంట్ లూప్ను వేగంగా మరియు కాంటెక్స్ట్-ఎఫిషియంట్గా మారుస్తాయి, తద్వారా మోడల్ రా టెర్మినల్ లాగ్స్తో ఒత్తిడికి గురికాకుండా సంబంధిత ఫలితాలపై రీజనింగ్ కొనసాగించగలదు.
ఏజెంట్ లూప్స్లో ఒక సమస్య ఏమిటంటే టాస్క్స్ చాలా కాలం పాటు నడవవచ్చు. ఎక్కువ సమయం నడిచే టాస్క్స్ కాంటెక్స్ట్ విండోను నింపేస్తాయి, ఇది టర్న్స్ మరియు ఏజెంట్స్ మధ్య కాంటెక్స్ట్ ఇవ్వడానికి ముఖ్యమైనది. ఒక ఏజెంట్ స్కిల్ను కాల్ చేసి, రెస్పాన్స్ పొందుతూ, టూల్ కాల్స్ మరియు రీజనింగ్ సమ్మరీలను జోడిస్తే—పరిమిత కాంటెక్స్ట్ విండో త్వరగా నిండిపోతుంది. ఏజెంట్ కొనసాగుతున్నప్పుడు ముఖ్యమైన కాంటెక్స్ట్ కోల్పోకుండా ఉండేందుకు, కీలక వివరాలను ఉంచి అవసరం లేని వాటిని తొలగించే విధానం అవసరం. డెవలపర్స్ కస్టమ్ సమ్మరైజేషన్ లేదా స్టేట్-క్యారింగ్ సిస్టమ్స్ను డిజైన్ చేసి మెయింటైన్ చేయాల్సిన అవసరం లేకుండా, మోడల్ ఎలా ప్రవర్తిస్తుందో మరియు ఎలా ట్రెయిన్ చేయబడిందో అనుసరించేలా Responses APIలో నేటివ్ కంపాక్షన్ను జోడించాము.
మా తాజా మోడల్స్ ముందున్న సంభాషణ స్టేట్ను విశ్లేషించి, కీలకమైన స్టేట్ను ఎన్క్రిప్టెడ్ మరియు టోకెన్-ఎఫిషియెంట్ రిప్రజెంటేషన్లో నిలుపుకునే కంపాక్షన్ ఐటమ్ను తయారు చేయడానికి ట్రెయిన్ చేయబడ్డాయి.కంపాక్షన్ తర్వాత, తదుపరి కాంటెక్స్ట్ విండోలో ఈ కంపాక్షన్ ఐటమ్ మరియు ముందున్న విండోలోని హై-వాల్యూ భాగాలు ఉంటాయి. దీని వల్ల వర్క్ఫ్లోలు విండో బౌండరీలను దాటి కూడా క్రమబద్ధంగా కొనసాగుతాయి, ముఖ్యంగా పొడవైన మల్టీ-స్టెప్ మరియు టూల్-డ్రివెన్ సెషన్స్లో కూడా. Codex ఈ మెకానిజంపై ఆధారపడుతుంది, దీని ద్వారా క్వాలిటీ తగ్గకుండా లాంగ్-రన్నింగ్ కోడింగ్ టాస్క్స్ మరియు ఇటరేటివ్ టూల్ ఎగ్జిక్యూషన్ కొనసాగుతుంది.
కంపాక్షన్ సర్వర్లో బిల్ట్-ఇన్గా లేదా స్టాండలోన్ /compact ఎండ్పాయింట్ ద్వారా అందుబాటులో ఉంటుంది. సర్వర్-సైడ్ కంపాక్షన్లో మీరు ఒక థ్రెషోల్డ్ను సెట్ చేయవచ్చు, మరియు సిస్టమ్ కంపాక్షన్ టైమింగ్ను ఆటోమేటిక్గా నిర్వహిస్తుంది, దీంతో క్లిష్టమైన క్లయింట్-సైడ్ లాజిక్ అవసరం ఉండదు. ఇది కంపాక్షన్కు ముందు చిన్న ఓవర్ేజెస్ను సహించేలా కొంచెం పెద్ద ఎఫెక్టివ్ ఇన్పుట్ కాంటెక్స్ట్ విండోను అనుమతిస్తుంది, అందువల్ల లిమిట్కు దగ్గరగా ఉన్న రిక్వెస్టులు కూడా రిజెక్ట్ కాకుండా ప్రాసెస్ అయ్యి కంపాక్ట్ చేయబడతాయి. మోడల్ ట్రైనింగ్ అభివృద్ధి చెందుతున్న కొద్దీ, ప్రతి OpenAI మోడల్ రిలీజ్తో పాటు నేటివ్ కంపాక్షన్ సొల్యూషన్ కూడా అభివృద్ధి చెందుతుంది.
Codex ప్రారంభ వినియోగదారుడిగా ఉండి, కంపాక్షన్ సిస్టమ్ను నిర్మించడంలో మాకు సహాయపడింది. ఒక Codex ఇన్స్టాన్స్కు కంపాక్షన్ ఎర్రర్ వచ్చినప్పుడు, దాన్ని పరిశీలించడానికి మేము మరో ఇన్స్టాన్స్ను స్పిన్ అప్ చేసేవాళ్లం. ఫలితంగా, Codex సమస్యపై పని చేస్తూనే ఒక నేటివ్ మరియు ప్రభావవంతమైన కంపాక్షన్ సిస్టమ్ను పొందింది. Codex తనను తాను పరిశీలించి మెరుగుపరుచుకునే ఈ సామర్థ్యం OpenAIలో పని చేయడంలో ఒక ప్రత్యేకంగా ఆసక్తికరమైన అంశంగా మారింది. చాలా టూల్స్ వినియోగదారు వాటిని ఎలా ఉపయోగించాలో నేర్చుకోవాల్సి ఉంటుంది; కానీ Codex మనతో పాటు నేర్చుకుంటుంది.
ఇప్పుడు స్టేట్ మరియు రిసోర్సెస్ గురించి చూద్దాం. కంటైనర్ కమాండ్స్ను రన్ చేయడానికి మాత్రమే కాదు, మోడల్కు వర్కింగ్ కాంటెక్స్ట్గా కూడా పనిచేస్తుంది. కంటైనర్ లోపల, మోడల్ ఫైల్స్ను చదవగలదు, డేటాబేసులను క్వెరీ చేయగలదు, మరియు నెట్వర్క్ పాలసీ కంట్రోల్స్ కింద ఎక్స్టర్నల్ సిస్టమ్స్ను యాక్సెస్ చేయగలదు.
కంటైనర్ కాంటెక్స్ట్లో మొదటి భాగం రిసోర్సెస్ను అప్లోడ్ చేయడానికి, ఆర్గనైజ్ చేయడానికి, మరియు మేనేజ్ చేయడానికి ఉపయోగించే ఫైల్ సిస్టమ్. అందుబాటులో ఉన్న డేటాకు మ్యాప్ను మోడల్కు ఇవ్వడానికి మరియు విస్తృతమైన, నాయిజీ స్కాన్స్ చేయకుండా టార్గెటెడ్ ఫైల్ ఆపరేషన్స్ను ఎంచుకోవడానికి సహాయపడేలా మేము container and file(కొత్త విండోలో తెరుచుకుంటుంది) APIsను నిర్మించాము.
ఒక సాధారణ యాంటీ-ప్యాటర్న్ అంటే అన్ని ఇన్పుట్ను నేరుగా ప్రాంప్ట్ కాంటెక్స్ట్లో పెట్టడం. ఇన్పుట్స్ పెరిగేకొద్దీ, ప్రాంప్ట్ను ఎక్కువగా నింపడం ఖరీదైనదిగా మారి, మోడల్కు నావిగేట్ చేయడం కష్టమవుతుంది. మంచి ప్యాటర్న్ ఏమిటంటే, రిసోర్సెస్ను కంటైనర్ ఫైల్ సిస్టమ్లో స్టేజ్ చేసి, షెల్ కమాండ్స్ ద్వారా ఏవి ఓపెన్ చేయాలి, పార్స్ చేయాలి లేదా ట్రాన్స్ఫార్మ్ చేయాలో మోడల్కు నిర్ణయించనివ్వడం. మనుషుల మాదిరిగానే, మోడల్స్ కూడా సక్రమంగా ఆర్గనైజ్ చేసిన సమాచారంతో మెరుగ్గా పనిచేస్తాయి.
కంటైనర్ కాంటెక్స్ట్లో రెండవ భాగం డేటాబేసులు. చాలా సందర్భాల్లో, స్ట్రక్చర్డ్ డేటాను SQLite వంటి డేటాబేసుల్లో స్టోర్ చేసి వాటిని క్వెరీ చేయాలని మేము డెవలపర్స్కు సూచిస్తాము. ఉదాహరణకు, మొత్తం స్ప్రెడ్షీట్ను ప్రాంప్ట్లో కాపీ చేయడం బదులుగా, టేబుల్స్ గురించి—ఏ కాలమ్స్ ఉన్నాయి మరియు వాటి అర్థం ఏమిటి—అనే వివరణను మోడల్కు ఇచ్చి, అవసరమైన రోస్ను మాత్రమే తీసుకునేలా చేయవచ్చు.
ఉదాహరణకు, “ఈ క్వార్టర్లో ఏ ప్రొడక్ట్స్ సేల్స్ తగ్గాయి?” అని అడిగితే, మోడల్ మొత్తం స్ప్రెడ్షీట్ను స్కాన్ చేయకుండా కేవలం సంబంధిత రోస్ను మాత్రమే క్వెరీ చేస్తుంది. ఇది వేగంగా, తక్కువ ఖర్చుతో, పెద్ద డేటాసెట్స్కు మరింత స్కేలబుల్గా ఉంటుంది.
కంటైనర్ కాంటెక్స్ట్లో మూడవ భాగం నెట్వర్క్ యాక్సెస్, ఇది ఏజెంట్ వర్క్లోడ్స్కు చాలా ముఖ్యమైన భాగం. ఏజెంట్ వర్క్ఫ్లోలో లైవ్ డేటా ఫెచ్ చేయడం, ఎక్స్టర్నల్ APIs కాల్ చేయడం, లేదా ప్యాకేజెస్ ఇన్స్టాల్ చేయడం అవసరం కావచ్చు. అదే సమయంలో, కంటైనర్లకు అనియంత్రిత ఇంటర్నెట్ యాక్సెస్ ఇవ్వడం రిస్కీ: ఇది సమాచారం ఎక్స్టర్నల్ వెబ్సైట్లకు బయటపడేలా చేయవచ్చు, అనుకోకుండా సెన్సిటివ్ ఇంటర్నల్ లేదా థర్డ్-పార్టీ సిస్టమ్స్ను టచ్ చేయవచ్చు, లేదా క్రెడెన్షియల్ లీక్స్ మరియు డేటా ఎక్స్ఫిల్ట్రేషన్ను నియంత్రించడం కష్టతరం చేయవచ్చు.
ఈ సమస్యలను పరిష్కరించడానికి, ఏజెంట్స్ ఉపయోగాన్ని తగ్గించకుండా, మేము హోస్టెడ్ కంటైనర్లలో సైడ్కార్ ఎగ్రెస్ ప్రాక్సీని ఉపయోగించేలా నిర్మించాము. అన్ని అవుట్బౌండ్ నెట్వర్క్ రిక్వెస్టులు ఒక సెంట్రలైజ్డ్ పాలసీ లేయర్ ద్వారా ప్రవహిస్తాయి, ఇది అలౌలిస్ట్స్ మరియు యాక్సెస్ కంట్రోల్స్ను అమలు చేస్తుంది, అలాగే ట్రాఫిక్ను ఆబ్జర్వబుల్గా ఉంచుతుంది. క్రెడెన్షియల్స్ కోసం, మేము ఎగ్రెస్ వద్ద డొమైన్-స్కోప్డ్ సీక్రెట్ ఇంజెక్షన్ను ఉపయోగిస్తాము. మోడల్ మరియు కంటైనర్ ప్లేస్హోల్డర్స్ మాత్రమే చూస్తాయి, కానీ అసలు సీక్రెట్ విల్యూస్ మోడల్కు కనిపించని కాంటెక్స్ట్ బయటే ఉంటాయి మరియు ఆమోదించబడిన డెస్టినేషన్స్కు మాత్రమే అప్లై అవుతాయి. ఇది లీకేజీ రిస్క్ను తగ్గిస్తూ, ఆథెంటికేటెడ్ ఎక్స్టర్నల్ కాల్స్ను కొనసాగించేందుకు సహాయపడుతుంది.
షెల్ కమాండ్స్ శక్తివంతమైనవి, కానీ చాలా టాస్క్స్ ఒకే మల్టీ-స్టెప్ ప్యాటర్న్స్ను పునరావృతం చేస్తాయి. ఏజెంట్స్ ప్రతి రన్లో వర్క్ఫ్లోను మళ్లీ గుర్తించాలి—రీప్లానింగ్, కమాండ్స్ను మళ్లీ ఇష్యూ చేయడం, కన్వెన్షన్స్ను మళ్లీ నేర్చుకోవడం—దీంతో అసంఖ్యాకమైన ఫలితాలు మరియు వృథా ఎగ్జిక్యూషన్ జరుగుతుంది. Agent skills(కొత్త విండోలో తెరుచుకుంటుంది) ఆ ప్యాటర్న్స్ను మళ్లీ ఉపయోగించగల, కాంపోజ్ చేయగల బిల్డింగ్ బ్లాక్స్గా ప్యాకేజ్ చేస్తాయి. స్పష్టంగా చెప్పాలంటే, ఒక స్కిల్ అనేది ‘SKILL.md(కొత్త విండోలో తెరుచుకుంటుంది)’ను కలిగి ఉన్న ఫోల్డర్ బండిల్ (మెటాడేటా మరియు ఇన్స్ట్రక్షన్స్ కలిగి ఉంటుంది) అలాగే API స్పెక్స్ మరియు UI అసెట్స్ వంటి సపోర్టింగ్ రిసోర్సెస్ కూడా ఉంటాయి.
ఈ స్ట్రక్చర్, ముందుగా వివరించిన రన్టైమ్ ఆర్కిటెక్చర్కు సహజంగా సరిపోతుంది. కంటైనర్ పర్సిస్టెంట్ ఫైల్స్ మరియు ఎగ్జిక్యూషన్ కాంటెక్స్ట్ను అందిస్తుంది, మరియు షెల్ టూల్ ఎగ్జిక్యూషన్ ఇంటర్ఫేస్ను అందిస్తుంది. ఇవి రెండూ ఉన్నప్పుడు, మోడల్ అవసరమైనప్పుడు షెల్ కమాండ్స్ (ls, cat, etc.) ఉపయోగించి స్కిల్ ఫైల్స్ను కనుగొనగలదు, ఇన్స్ట్రక్షన్స్ను అర్థం చేసుకుని, అదే ఏజెంట్ లూప్లో స్కిల్ స్క్రిప్ట్స్ను రన్ చేయగలదు.
OpenAI ప్లాట్ఫారమ్లో స్కిల్స్ను మేనేజ్ చేయడానికి మేము APIs(కొత్త విండోలో తెరుచుకుంటుంది) అందిస్తున్నాము. డెవలపర్స్ స్కిల్ ఫోల్డర్స్ను వెర్షన్ చేయబడిన బండిల్స్గా అప్లోడ్ చేసి స్టోర్ చేస్తారు, తరువాత వాటిని స్కిల్ ID ద్వారా తిరిగి పొందవచ్చు. ప్రాంప్ట్ను మోడల్కు పంపే ముందు, Responses API స్కిల్ను లోడ్ చేసి మోడల్ కాంటెక్స్ట్లో చేర్చుతుంది. ఈ సీక్వెన్స్ డిటర్మినిస్టిక్:
- స్కిల్ మెటాడేటా (పేరు మరియు వివరణతో సహా)ను ఫెచ్ చేయండి.
- స్కిల్ బండిల్ను ఫెచ్ చేసి, కంటైనర్లో కాపీ చేసి, అన్ప్యాక్ చేయండి.
- స్కిల్ మెటాడేటా మరియు కంటైనర్ పాత్తో మోడల్ కాంటెక్స్ట్ను అప్డేట్ చేయండి.
ఒక స్కిల్ సంబంధితదా అని నిర్ణయించే సమయంలో, మోడల్ దాని ఇన్స్ట్రక్షన్స్ను క్రమంగా అన్వేషించి, కంటైనర్లో షెల్ కమాండ్స్ ద్వారా స్క్రిప్ట్స్ను ఎగ్జిక్యూట్ చేస్తుంది.
అన్ని భాగాలను కలిపి చెప్పాలంటే: Responses API ఆర్కెస్ట్రేషన్ను అందిస్తుంది, shell tool ఎగ్జిక్యూటబుల్ యాక్షన్స్ను అందిస్తుంది, hosted container పర్సిస్టెంట్ రన్టైమ్ కాంటెక్స్ట్ను అందిస్తుంది, skills మళ్లీ ఉపయోగించగల వర్క్ఫ్లో లాజిక్ను లేయర్గా అందిస్తాయి, మరియు compaction అవసరమైన కాంటెక్స్ట్తో ఏజెంట్ ఎక్కువ సమయం రన్ అయ్యేలా చేస్తుంది.
ఈ ప్రిమిటివ్స్తో, ఒకే ప్రాంప్ట్ ఎండ్-టు-ఎండ్ వర్క్ఫ్లోగా విస్తరించవచ్చు: సరైన స్కిల్ను కనుగొనడం, డేటాను ఫెచ్ చేయడం, దాన్ని లోకల్ స్ట్రక్చర్డ్ స్టేట్గా మార్చడం, సమర్థవంతంగా క్వెరీ చేయడం, మరియు నిలకడైన ఆర్టిఫాక్ట్స్ను జనరేట్ చేయడం.
కింద ఉన్న డయాగ్రామ్ లైవ్ డేటా నుండి స్ప్రెడ్షీట్ రూపొందించడానికి ఈ సిస్టమ్ ఎలా పనిచేస్తుందో చూపిస్తుంది.
Responses API ఒక ఏజెంటిక్ టాస్క్ను ఆర్కెస్ట్రేట్ చేస్తుంది
ఎండ్-టు-ఎండ్ వర్క్ఫ్లోల కోసం షెల్ టూల్ మరియు కంప్యూటర్ ఎన్విరాన్మెంట్ను కలిపిన లోతైన ఉదాహరణ కోసం, ఒక స్కిల్ను ప్యాకేజ్ చేసి Responses API ద్వారా ఎగ్జిక్యూట్ చేసే విధానాన్ని వివరించే మా developer blog post(కొత్త విండోలో తెరుచుకుంటుంది) మరియు cookbook(కొత్త విండోలో తెరుచుకుంటుంది) చూడండి.
ఈ ప్రిమిటివ్స్ సెట్తో డెవలపర్స్ ఏమి నిర్మిస్తారో చూడటానికి మేము ఉత్సాహంగా ఉన్నాము. లాంగ్వేజ్ మోడల్స్ టెక్స్ట్, ఇమేజెస్, ఆడియో మాత్రమే కాదు—కాంప్లెక్స్ రియల్-వరల్డ్ టాస్క్స్ను స్కేల్లో హ్యాండిల్ చేయగల సామర్థ్యాన్ని పెంచుతూ మా ప్లాట్ఫారమ్ను మరింత అభివృద్ధి చేస్తూనే ఉంటాము.
