37,065 results · Most relevant
Jesse Hall recommends a checklist for building voice agents: set the latency budget first, measure perceived latency, and spend whatever budget is left on model quality rather than on speed that doesn't matter.
Patterson recommends placing a model proxy or gateway between the agent and the LLM provider. The proxy sniffs and logs all traffic for full visibility, sanitizes content, strips prompt injections, and removes sensitive data like credit card numbers before prompts reach the provider.
Patterson's third architectural protection: an agentic firewall that monitors process logs and denies dangerous commands the agent hasn't been pre-approved to run, such as 'gh repo delete' or dropping a database table. Without it, an agent running unapproved commands can cause irreversible damage.
Patterson's second pillar: restrict the agent's external communication. Isolate it from your network, allow only whitelisted domains, and put the agent's VM on your VPN and behind a firewall so all agent traffic is governed and visible. He also recommends alerting admins when an agent breaches its perimeter so they can kill the agent, while noting that alert fatigue can make everything AI does become noise.
Patterson's first pillar of agentic security: don't put agents on your local machine, where they can access unintended credentials and data. Instead, run them in an isolated cloud development environment accessed via URL, RDP, or SSH, with right-scoped permissions and no external communication unless explicitly allowed.
Use the agent command in the CLI to set up a workflow that adds an agent into your CLI environment. When creating the agent, choose whether it lives at the project level or the user level so it's available regardless of project. Copilot scaffolds the entire agent for you: description, front matter, success criteria, and methodology structure. You just write a general one-line description of what you want the agent to do and let the builder fill in the specifics.
When you want an agent to run as part of the repository rather than locally, the creator points to the agentic workflows framework using the Copilot CLI in headless mode inside a CI system, which can be triggered on events happening in the repo.
The creator recommends instrumenting every agent running in the pipeline with Otel so you can go to a SIM or logging platform and analyze how agents run across repositories and how much they cost, including pivoting on average token use.
The app server comes as part of the Codex CLI — it's the same binary, so if you have the CLI you can spin up the app server right now. But you should bundle the app server binary with your application so you have full control over the capabilities of the version you're building against, since the protocol regularly changes between versions.
Dominik Kundel warns against rushing to write your own system prompt: OpenAI constantly tunes the harness to keep prompts in distribution and the agent performing well, and you lose all of that by replacing base instructions. If changing instructions, start by adding developer instructions rather than changing the base instructions.
Dominik Kundel advises starting with developer instructions rather than changing base instructions when customizing the agent. Rushing to write your own system prompt loses the harness team's work keeping the prompt in distribution so the agent performs well; he says to be careful if you do write your own.
Dominik Kundel recommends the app server when building a more comprehensive client that shows the agent, or when spinning up many Codex threads at once — such as running your own eval harness — because it gives full control over the harness and avoids hand-rolling parallelization of CodexExec calls.
The two biggest things to look at when customizing the agent on the app server are developer instructions — appending on top of Codex's system prompt rather than replacing it, leveraging OpenAI's prompt-tuning work while customizing for your use case (this is what OpenAI does in the Codex app, since some functionality is app-specific) — and bringing tools: dynamic tools expose additional functions via MCP or by defining tools directly, and can be marked as deferred loading so Codex finds them via a tool search tool instead of polluting the context window.
Dominik Kundel recommends exposing new functions as part of your interface but marking them deferred, so you avoid polluting the context window and confusing the agent while keeping the functions available. He notes the Codex app does this so the agent can control itself, e.g. spinning up automations.
Dominik Kundel advises shipping your own version of the harness to eliminate many headaches: relying on the user's installed CLI means constantly running into breaking changes (especially with experimental features, even though OpenAI tries to minimize them), and worrying about whether users have updated to get the latest features or nudging them to update.
Dominik Kundel recommends shipping your own harness to eliminate headaches: relying on the user's installed CLI exposes you to breaking changes (especially with experimental features) and forces you to worry about whether users updated to a version with the feature you need.
Pedro Lopez explains that CLIs invoked by agents cannot assume a human is present to answer interactive prompts; such CLIs get stuck. Inputs should be exposed via flags, and credentials via environment variables and config files so setup can happen out of band.
When starting with a customer, be transparent about three things: show what works (state the reliability level they can trust), tell them what you're doing to improve (acknowledge known gaps you're investing time to fix), and tell them what is out of scope — if something doesn't work, say so and don't let them try it.
Commercial context: The creator presents this as their own offering and directs viewers to get it.
Viren Baraiya walks through an SRE agent as a remediation loop: step one is a call to the LLM, whose output is the steps the agent should do; the harness then executes those steps as a deterministic workflow. The loop first understands the root cause of the problem, reacts to it, observes the output, and then runs another loop to plan the next set of steps — essentially a remediation loop that runs twice. The agent's job is to understand what's going on in the current system, plan what should happen next, and execute on those things.
Engineers should optimize for this new world by decomposing needs into their simplest chunks, which lends to understanding, simpler code surfaces, and control of code bases. Teams used to break a feature into small atomic pieces they could reason about — small enough to hold in your head.
Choose sources → to get a library of your own and a daily brief.