On this tutorial, we construct and function a totally native, schema-valid OpenClaw runtime. We configure the OpenClaw gateway with strict loopback binding, arrange authenticated mannequin entry by surroundings variables, and outline a safe execution surroundings utilizing the built-in exec device. We then create a structured customized talent that the OpenClaw agent can uncover and invoke deterministically. As an alternative of manually working Python scripts, we permit OpenClaw to orchestrate mannequin reasoning, talent choice, and managed device execution by its agent runtime. All through the method, we give attention to OpenClaw’s structure, gateway management airplane, agent defaults, mannequin routing, and talent abstraction to know how OpenClaw coordinates autonomous habits in a safe, local-first setup.
import os, json, textwrap, subprocess, time, re, pathlib, shlex
from getpass import getpass
def sh(cmd, test=True, seize=False, env=None):
p = subprocess.run(
["bash", "-lc", cmd],
test=test,
textual content=True,
capture_output=seize,
env=env or os.environ.copy(),
)
return p.stdout if seize else None
def require_secret_env(var="OPENAI_API_KEY"):
if os.environ.get(var, "").strip():
return
key = getpass(f"Enter {var} (hidden): ").strip()
if not key:
increase RuntimeError(f"{var} is required.")
os.environ[var] = key
def install_node_22_and_openclaw():
sh("sudo apt-get replace -y")
sh("sudo apt-get set up -y ca-certificates curl gnupg")
sh("curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -")
sh("sudo apt-get set up -y nodejs")
sh("node -v && npm -v")
sh("npm set up -g openclaw@newest")
sh("openclaw --version", test=False)We outline the core utility capabilities that permit us to execute shell instructions, securely seize surroundings variables, and set up OpenClaw with the required Node.js runtime. We set up the foundational management interface that connects Python execution with the OpenClaw CLI. Right here, we put together the surroundings in order that OpenClaw can operate because the central agent runtime inside Colab.
def write_openclaw_config_valid():
residence = pathlib.Path.residence()
base = residence / ".openclaw"
workspace = base / "workspace"
(workspace / "expertise").mkdir(mother and father=True, exist_ok=True)
cfg = {
"gateway": {
"mode": "native",
"port": 18789,
"bind": "loopback",
"auth": {"mode": "none"},
"controlUi": {
"enabled": True,
"basePath": "/openclaw",
"dangerouslyDisableDeviceAuth": True
}
},
"brokers": {
"defaults": {
"workspace": str(workspace),
"mannequin": {"main": "openai/gpt-4o-mini"}
}
},
"instruments": {
"exec": {
"backgroundMs": 10000,
"timeoutSec": 1800,
"cleanupMs": 1800000,
"notifyOnExit": True,
"notifyOnExitEmptySuccess": False,
"applyPatch": {"enabled": False, "allowModels": ["openai/gpt-5.2"]}
}
}
}
base.mkdir(mother and father=True, exist_ok=True)
(base / "openclaw.json").write_text(json.dumps(cfg, indent=2))
return str(base / "openclaw.json")
def start_gateway_background():
sh("rm -f /tmp/openclaw_gateway.log /tmp/openclaw_gateway.pid", test=False)
sh("nohup openclaw gateway --port 18789 --bind loopback --verbose > /tmp/openclaw_gateway.log 2>&1 & echo $! > /tmp/openclaw_gateway.pid")
for _ in vary(60):
time.sleep(1)
log = sh("tail -n 120 /tmp/openclaw_gateway.log || true", seize=True, test=False) or ""
if re.search(r"(listening|prepared|ws|http).*18789|18789.*listening", log, re.IGNORECASE):
return True
print("Gateway log tail:n", sh("tail -n 220 /tmp/openclaw_gateway.log || true", seize=True, test=False))
increase RuntimeError("OpenClaw gateway didn't begin cleanly.")We write a schema-valid OpenClaw configuration file and initialize the native gateway settings. We outline the workspace, mannequin routing, and execution device habits in accordance with the official OpenClaw configuration construction. We then begin the OpenClaw gateway in loopback mode to make sure the agent runtime launches appropriately and securely.
def pick_model_from_openclaw():
out = sh("openclaw fashions checklist --json", seize=True, test=False) or ""
refs = []
attempt:
information = json.masses(out)
if isinstance(information, dict):
for ok in ["models", "items", "list"]:
if isinstance(information.get(ok), checklist):
information = information[k]
break
if isinstance(information, checklist):
for it in information:
if isinstance(it, str) and "/" in it:
refs.append(it)
elif isinstance(it, dict):
for key in ["ref", "id", "model", "name"]:
v = it.get(key)
if isinstance(v, str) and "/" in v:
refs.append(v)
break
besides Exception:
move
refs = [r for r in refs if r.startswith("openai/")]
most popular = ["openai/gpt-4o-mini", "openai/gpt-4.1-mini", "openai/gpt-4o", "openai/gpt-5.2-mini", "openai/gpt-5.2"]
for p in most popular:
if p in refs:
return p
return refs[0] if refs else "openai/gpt-4o-mini"
def set_default_model(model_ref):
sh(f'openclaw config set brokers.defaults.mannequin.main "{model_ref}"', test=False)We dynamically question OpenClaw for obtainable fashions and choose an acceptable OpenAI supplier mannequin. We programmatically configure the agent defaults in order that OpenClaw routes all reasoning requests by the chosen mannequin. Right here, we permit OpenClaw to deal with mannequin abstraction and supplier authentication seamlessly.
def create_custom_skill_rag():
residence = pathlib.Path.residence()
skill_dir = residence / ".openclaw" / "workspace" / "expertise" / "colab_rag_lab"
skill_dir.mkdir(mother and father=True, exist_ok=True)
tool_py = skill_dir / "rag_tool.py"
tool_py.write_text(textwrap.dedent(r"""
import sys, re, subprocess
def pip(*args): subprocess.check_call([sys.executable, "-m", "pip", "-q", "install", *args])
q = " ".be a part of(sys.argv[1:]).strip()
if not q:
print("Utilization: python3 rag_tool.py ", file=sys.stderr)
increase SystemExit(2)
attempt:
import numpy as np
besides Exception:
pip("numpy"); import numpy as np
attempt:
import faiss
besides Exception:
pip("faiss-cpu"); import faiss
attempt:
from sentence_transformers import SentenceTransformer
besides Exception:
pip("sentence-transformers"); from sentence_transformers import SentenceTransformer
CORPUS = [
("OpenClaw basics", "OpenClaw runs an agent runtime behind a local gateway and can execute tools and skills in a controlled way."),
("Strict config schema", "OpenClaw gateway refuses to start if openclaw.json has unknown keys; use openclaw doctor to diagnose issues."),
("Exec tool config", "tools.exec config sets timeouts and behavior; it does not use an enabled flag in the config schema."),
("Gateway auth", "Even on localhost, gateway auth exists; auth.mode can be none for trusted loopback-only setups."),
("Skills", "Skills define repeatable tool-use patterns; agents can select a skill and then call exec with a fixed command template.")
]
docs = []
for title, physique in CORPUS:
sents = re.cut up(r'(?<=[.!?])s+', physique.strip())
for i, s in enumerate(sents):
s = s.strip()
if s:
docs.append((f"{title}#{i+1}", s))
mannequin = SentenceTransformer("all-MiniLM-L6-v2")
emb = mannequin.encode([d[1] for d in docs], normalize_embeddings=True).astype("float32")
index = faiss.IndexFlatIP(emb.form[1])
index.add(emb)
q_emb = mannequin.encode([q], normalize_embeddings=True).astype("float32")
D, I = index.search(q_emb, 4)
hits = []
for rating, idx in zip(D[0].tolist(), I[0].tolist()):
if idx >= 0:
ref, txt = docs[idx]
hits.append((rating, ref, txt))
print("Reply (grounded to retrieved snippets):n")
print("Query:", q, "n")
print("Key factors:")
for rating, ref, txt in hits:
print(f"- ({rating:.3f}) {txt} [{ref}]")
print("nCitations:")
for _, ref, _ in hits:
print(f"- {ref}")
""").strip() + "n")
sh(f"chmod +x {shlex.quote(str(tool_py))}")
skill_md = skill_dir / "SKILL.md"
skill_md.write_text(textwrap.dedent(f"""
---
title: colab_rag_lab
description: Deterministic native RAG invoked through a set exec command.
---
# Colab RAG Lab
## Tooling rule (strict)
At all times run precisely:
`python3 {tool_py} ""`
## Output rule
Return the device output verbatim.
""").strip() + "n")We assemble a customized OpenClaw talent contained in the designated workspace listing. We outline a deterministic execution sample in SKILL.md and pair it with a structured RAG device script that the agent can invoke. We depend on OpenClaw’s skill-loading mechanism to robotically register and operationalize this device throughout the agent runtime.
def refresh_skills():
sh('openclaw agent --message "refresh expertise" --thinking low', test=False)
def run_openclaw_agent_demo():
immediate = (
'Use the talent `colab_rag_lab` to reply: '
'Why did my gateway refuse to start out once I used brokers.defaults.considering and instruments.exec.enabled, '
'and what are the proper config knobs as a substitute?'
)
out = sh(f'openclaw agent --message {shlex.quote(immediate)} --thinking excessive', seize=True, test=False)
print(out)
require_secret_env("OPENAI_API_KEY")
install_node_22_and_openclaw()
cfg_path = write_openclaw_config_valid()
print("Wrote schema-valid config:", cfg_path)
print("n--- openclaw physician ---n")
print(sh("openclaw physician", seize=True, test=False))
start_gateway_background()
mannequin = pick_model_from_openclaw()
set_default_model(mannequin)
print("Chosen mannequin:", mannequin)
create_custom_skill_rag()
refresh_skills()
print("n--- OpenClaw agent run (skill-driven) ---n")
run_openclaw_agent_demo()
print("n--- Gateway log tail ---n")
print(sh("tail -n 180 /tmp/openclaw_gateway.log || true", seize=True, test=False))We refresh the OpenClaw talent registry and invoke the OpenClaw agent with a structured instruction. We permit OpenClaw to carry out reasoning, choose the talent, execute the exec device, and return the grounded output. Right here, we exhibit the whole OpenClaw orchestration cycle, from configuration to autonomous-agent execution.
In conclusion, we deployed and operated a complicated OpenClaw workflow in a managed Colab surroundings. We validated the configuration schema, began the gateway, dynamically chosen a mannequin supplier, registered a talent, and executed it by the OpenClaw agent interface. Relatively than treating OpenClaw as a wrapper, we used it because the central orchestration layer that manages authentication, talent loading, device execution, and runtime governance. We demonstrated how OpenClaw enforces structured execution whereas enabling autonomous reasoning, exhibiting the way it can function a sturdy basis for constructing safe, extensible agent programs in production-oriented environments.
Take a look at the Full Codes here. Additionally, be happy to observe us on Twitter and don’t overlook to affix our 120k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.
Have to accomplice with us for selling your GitHub Repo OR Hugging Face Web page OR Product Launch OR Webinar and so forth.? Connect with us
