## The Evolution from Chat Completions to Agentic Systems
February 2026 marks a pivotal moment in AI infrastructure: OpenAI’s Responses API has evolved from a simple chat interface to a comprehensive platform for building, deploying, and managing production AI agents. With the deprecation of the Assistants API (sunset August 26, 2026) and the ChatGPT-4o endpoint (deprecated February 17, 2026), the Responses API now stands as the unified foundation for all OpenAI-powered AI applications.
This upgrade introduces three transformative capabilities specifically designed for long-running AI agents: **skills** as reusable workflow packages, **server-side compression** for infinite-context sessions, and **controlled internet access** within hosted containers. Combined, these features enable developers to build AI systems that can operate for hours, days, or even weeks without manual intervention.
## Skills: Reusable Workflow Packages for AI Agents
### From Monolithic Prompts to Modular Skills
Traditional AI agent development suffered from “prompt bloat”—thousands of tokens of instructions duplicated across every interaction. Skills solve this by packaging instructions, scripts, and files into versioned, reusable components:
“`python
# skills/customer-support/skill.yaml
name: customer-support-tier1
version: 2.1.0
description: “Tier 1 customer support agent for common inquiries”
author: “AI Engineering Team”
license: “MIT”
dependencies:
– name: ticket-system
version: “^1.3.0”
– name: knowledge-base
version: “^2.0.0”
– name: sentiment-analysis
version: “^1.1.0”
instructions: |
You are a Tier 1 customer support agent. Your responsibilities:
1. Greet customers professionally and identify their issue
2. Search knowledge base for solutions (max 3 attempts)
3. If solution found, provide step-by-step guidance
4. If no solution, escalate to Tier 2 with detailed context
5. Never make promises about resolution timelines
6. Always maintain empathetic tone
Escalation criteria:
– Technical issue requiring engineering
– Billing disputes over $100
– Security/privacy concerns
– Customer requests supervisor
tools:
– type: search
target: knowledge-base
parameters:
max_results: 5
relevance_threshold: 0.7
– type: create_ticket
target: zendesk
parameters:
priority: auto_determine
tags: [“tier1”, “auto-generated”]
– type: sentiment
target: sentiment-analysis
parameters:
model: “vader-enhanced”
alert_threshold: -0.5
files:
– path: escalation-procedures.md
description: “Step-by-step escalation workflow”
– path: common-solutions.json
description: “Frequently used solutions database”
– path: tone-guidelines.md
description: “Communication style requirements”
execution:
container: debian-12-python
resources:
cpu: “2”
memory: “4Gi”
storage: “10Gi”
timeout: 300 # seconds
retry_policy:
max_attempts: 3
backoff_factor: 2
“`
### Skill Execution Environment
Skills execute within controlled containers that provide isolated, reproducible environments:
“`dockerfile
# Generated Dockerfile for skill execution
FROM debian:12-slim
# Base dependencies
RUN apt-get update && apt-get install -y \
python3.11 \
python3-pip \
curl \
jq \
git \
&& rm -rf /var/lib/apt/lists/*
# Python environment
WORKDIR /skill
COPY requirements.txt .
RUN pip install –no-cache-dir -r requirements.txt
# Skill files
COPY . .
# Execution entrypoint
ENTRYPOINT [“python3”, “/skill/runner.py”]
CMD [“–skill-config”, “/skill/skill.yaml”]
“`
### Skill Registry and Version Management
OpenAI hosts a central skill registry with version control and dependency resolution:
“`python
# Skill management client
from openai.skills import SkillRegistry, SkillClient
# Initialize registry client
registry = SkillRegistry(
api_key=OPENAI_API_KEY,
api_version=”2025-03-01-preview”
)
# Search for available skills
search_results = registry.search(
query=”customer support”,
categories=[“support”, “conversational”],
min_rating=4.0,
verified_only=True
)
# Install a skill
skill = registry.install(
skill_id=”openai/customer-support-tier1″,
version=”2.1.0″,
environment=”production”
)
# Create skill client
client = SkillClient(
skill=skill,
runtime=”hosted”, # or “local”
config={
“api_keys”: {
“zendesk”: ZENDESK_API_KEY,
“sentiment”: SENTIMENT_API_KEY
},
“endpoints”: {
“knowledge_base”: KB_API_URL
}
}
)
# Execute skill
result = client.execute(
input_data={
“customer_query”: “My payment failed but money was deducted”,
“customer_id”: “cust_12345”,
“session_id”: “sess_67890”
},
context={
“previous_interactions”: 3,
“customer_tier”: “premium”,
“locale”: “en-US”
}
)
print(f”Skill execution ID: {result.execution_id}”)
print(f”Status: {result.status}”)
print(f”Output: {result.output}”)
print(f”Metrics: {result.metrics}”)
print(f”Cost: ${result.cost_usd}”)
“`
## Server-Side Compression: Infinite Context Sessions
### The Context Management Challenge
Long-running agents face the “context wall”—hitting token limits after hours of operation. Server-side compression solves this by intelligently summarizing and retaining only essential information:
“`python
# Manual compression control
import openai
from datetime import datetime, timedelta
client = openai.OpenAI(
api_key=OPENAI_API_KEY,
api_version=”2025-03-01-preview”
)
# Start a long-running session
session = client.responses.create(
model=”gpt-4o”,
messages=[{“role”: “user”, “content”: “Start monitoring system logs”}],
session_config={
“persistence”: “hosted”,
“timeout”: timedelta(hours=24),
“compression”: {
“strategy”: “adaptive”,
“target_retention”: 0.8, # Keep 80% of information value
“min_context_tokens”: 1000,
“max_context_tokens”: 128000
}
}
)
# Monitor session state
def check_session_health(session_id):
session_state = client.responses.retrieve(session_id)
metrics = {
“total_tokens”: session_state.usage.total_tokens,
“compression_ratio”: session_state.compression.ratio,
“retained_information”: session_state.compression.retained_score,
“memory_fragments”: len(session_state.memory.fragments),
“active_tools”: len(session_state.active_tools)
}
# Auto-compress if approaching limits
if session_state.usage.total_tokens > 100000:
print(“Approaching token limit, triggering compression…”)
compressed = client.responses.compact(session_id)
print(f”Compressed from {compressed.original_tokens} to {compressed.compressed_tokens} tokens”)
print(f”Information retention: {compressed.retention_score:.2%}”)
return metrics
# Server-side automatic compression
auto_session = client.responses.create(
model=”gpt-4o”,
messages=[{“role”: “user”, “content”: “Analyze these logs continuously”}],
session_config={
“persistence”: “hosted”,
“compression”: {
“mode”: “auto”,
“trigger”: {
“token_threshold”: 80000,
“time_interval”: “30m”,
“information_density”: 0.4
},
“algorithm”: “hierarchical”,
“preservation_rules”: {
“keep_facts”: True,
“keep_decisions”: True,
“keep_errors”: True,
“summarize_routine”: True
}
}
}
)
“`
### Compression Algorithms and Performance
OpenAI implements multiple compression strategies with different trade-offs:
| Algorithm | Compression Ratio | Speed | Information Retention | Best For |
|———–|——————-|——-|———————-|———-|
| **Hierarchical** | 5-8x | Medium | 85-92% | General conversations |
| **Extractive** | 3-5x | Fast | 70-80% | Technical discussions |
| **Abstractive** | 8-12x | Slow | 90-95% | Creative writing |
| **Hybrid** | 6-9x | Medium | 88-93% | Mixed content |
| **Semantic** | 4-7x | Fast | 75-85% | Code/structured data |
“`python
# Compression algorithm benchmarking
def benchmark_compression(text, algorithm):
start_time = time.time()
result = client.responses.compact(
session_id=”benchmark-session”,
content=text,
algorithm=algorithm,
evaluation_mode=True
)
duration = time.time() – start_time
return {
“algorithm”: algorithm,
“original_tokens”: result.original_tokens,
“compressed_tokens”: result.compressed_tokens,
“ratio”: result.compression_ratio,
“retention”: result.retention_score,
“duration_ms”: duration * 1000,
“tokens_per_second”: result.original_tokens / duration
}
# Test with different content types
content_types = {
“technical_docs”: load_file(“api-documentation.md”),
“conversation”: load_file(“customer-chat.json”),
“code_review”: load_file(“pull-request-diff.txt”),
“creative_writing”: load_file(“short-story.txt”)
}
algorithms = [“hierarchical”, “extractive”, “abstractive”, “hybrid”, “semantic”]
results = []
for content_name, content in content_types.items():
for algorithm in algorithms:
metrics = benchmark_compression(content, algorithm)
metrics[“content_type”] = content_name
results.append(metrics)
# Analyze optimal algorithm per content type
optimal_choices = {}
for content in content_types.keys():
content_results = [r for r in results if r[“content_type”] == content]
best = max(content_results, key=lambda x: x[“retention”] * (1/x[“duration_ms”]))
optimal_choices[content] = best[“algorithm”]
“`
## Hosted Containers: Debian 12 with Persistent Storage
### Container Specifications and Capabilities
OpenAI’s hosted containers provide fully managed execution environments:
“`yaml
# container-spec.yaml
version: “2026-02”
spec:
base_image: “debian:12-slim”
architecture: “x86_64” # or “arm64”
system_packages:
– python3.11
– python3-pip
– curl
– wget
– git
– jq
– vim
– htop
– net-tools
python_packages:
– “openai>=1.0.0”
– “requests>=2.31.0”
– “pandas>=2.0.0”
– “numpy>=1.24.0”
– “sqlalchemy>=2.0.0”
resources:
cpu: “2” # vCPUs
memory: “8Gi”
storage:
ephemeral: “20Gi”
persistent: “100Gi” # Mounted at /data
gpu: # Optional
type: “T4”
count: 1
networking:
outbound: true
allowed_domains:
– “*.openai.com”
– “*.github.com”
– “*.pypi.org”
port_forwarding:
– 8080:8080 # Local:Container
security:
user: “agent”
read_only_root: false
capabilities:
– “NET_BIND_SERVICE”
seccomp_profile: “default”
apparmor_profile: “openai-agent”
persistence:
enabled: true
paths:
– “/data/workspace”
– “/data/cache”
– “/data/logs”
backup:
frequency: “daily”
retention_days: 30
monitoring:
metrics:
– cpu_usage
– memory_usage
– network_io
– storage_io
logs:
level: “INFO”
retention: “7d”
alerts:
– resource_usage > 90%
– error_rate > 1%
“`
### Container Lifecycle Management
“`python
# Container management client
from openai.containers import ContainerClient, ContainerSpec
container_client = ContainerClient(
api_key=OPENAI_API_KEY,
api_version=”2025-03-01-preview”
)
# Create a container
container_spec = ContainerSpec(
name=”data-analysis-container”,
spec={
“base_image”: “debian:12-slim”,
“resources”: {
“cpu”: “4”,
“memory”: “16Gi”,
“storage”: “50Gi”
},
“python_packages”: [
“pandas”, “numpy”, “scikit-learn”, “matplotlib”
]
}
)
container = container_client.create(
spec=container_spec,
environment=”production”,
region=”us-east-1″
)
print(f”Container ID: {container.id}”)
print(f”Status: {container.status}”)
print(f”Endpoint: {container.endpoint}”)
print(f”SSH Command: {container.ssh_command}”)
# Execute commands in container
exec_result = container_client.execute(
container_id=container.id,
command=”python3 /workspace/analyze.py –input /data/dataset.csv”,
timeout=300
)
print(f”Exit code: {exec_result.exit_code}”)
print(f”Stdout: {exec_result.stdout[:500]}…”)
print(f”Stderr: {exec_result.stderr}”)
print(f”Duration: {exec_result.duration_ms}ms”)
# Interactive shell session
shell = container_client.shell(
container_id=container.id,
terminal_type=”xterm-256color”,
dimensions={“rows”: 40, “cols”: 120}
)
# Shell provides interactive terminal
shell.send(“ls -la /data/\n”)
response = shell.receive(timeout=5)
print(f”Directory listing: {response}”)
# Persistent storage access
storage = container_client.storage(
container_id=container.id,
mount_path=”/data”
)
# Upload files
storage.upload(
local_path=”./dataset.csv”,
remote_path=”/data/input/dataset.csv”
)
# Download results
storage.download(
remote_path=”/data/output/analysis_report.pdf”,
local_path=”./report.pdf”
)
# Monitor container metrics
metrics = container_client.metrics(
container_id=container.id,
time_range=”last_hour”,
metrics=[“cpu_usage”, “memory_usage”, “network_io”]
)
# Clean up
container_client.delete(container.id)
“`
## Terminal Shell Integration: Full System Access
### Secure Terminal Environment
The terminal shell provides controlled access to the container’s operating system:
“`python
# Terminal shell integration
from openai.terminal import TerminalClient, TerminalSession
terminal_client = TerminalClient(
api_key=OPENAI_API_KEY,
api_version=”2025-03-01-preview”
)
# Create terminal session
session = terminal_client.create_session(
container_id=container.id,
config={
“shell”: “bash”,
“environment”: {
“PATH”: “/usr/local/bin:/usr/bin:/bin”,
“PYTHONPATH”: “/workspace:/skill”,
“OPENAI_API_KEY”: “***” # Masked in logs
},
“working_directory”: “/workspace”,
“timeout”: 3600,
“output_mode”: “streaming”
}
)
# Execute commands
def execute_safe_command(command, timeout=30):
“””Execute command with safety checks”””
# Validate command against allowlist
allowed_commands = [
“ls”, “cat”, “grep”, “find”, “python”, “pip”,
“curl”, “wget”, “git”, “mkdir”, “rm”, “cp”, “mv”
]
cmd_base = command.split()[0]
if cmd_base not in allowed_commands:
raise ValueError(f”Command not allowed: {cmd_base}”)
# Execute with timeout
result = session.execute(
command=command,
timeout=timeout,
capture_output=True
)
# Log execution
execution_log = {
“timestamp”: datetime.now().isoformat(),
“command”: command,
“exit_code”: result.exit_code,
“stdout_length”: len(result.stdout),
“stderr_length”: len(result.stderr),
“duration_ms”: result.duration_ms
}
return result
# Example: Set up development environment
setup_commands = [
“git clone https://github.com/company/ai-agent.git /workspace/agent”,
“cd /workspace/agent && pip install -r requirements.txt”,
“mkdir -p /data/logs /data