Quality & Security
Keeping agent work safe and correct. Once agents do the work and the platform lets them run, these are the patterns that secure the inputs, harden the generated code, and verify the output -- guardrails, identity, code security, evals, and review -- the difference between an autonomous system you can trust and one you merely hope works.
The platform theme is about enabling agents to do work. This one is about trusting it. When humans stop reviewing every line, control cannot be a person at every desk; it has to be engineered into the system.
These patterns split into two halves. Security keeps the system from being exploited or shipping unsafe code -- policy and safety on the agent's traffic, identity and access so every action is attributable, and treating generated code as untrusted until it is scanned. Quality makes sure the output is actually right -- evaluation and automated review rather than assumption. (Organization-level governance -- cost, data, regulation -- lives in Scaling the Org.)
Using agents to do quality assurance at the pace agents produce code: generating and maintaining tests, running suites, exercising the app end-to-end, and surfacing regressions -- so "is it tested" keeps up with "is it written."
TechShared, comparable yardsticks for agentic coding -- the same tasks and grader run against every model, led by SWE-bench. The coarse capability filter for choosing what to trial, distinct from your own evals; useful but easy to over-trust, since benchmarks rot, leak, and do not reflect your codebase.
ProcessChecking AI-generated code with machines, not just human eyes -- because agents now produce code faster than people can read it. As generation gets cheap, review becomes the bottleneck, so verification shifts left and goes programmatic: tests the agent cannot bypass, static analysis, conformance checks, and adversarial reviewer agents.
TechTreat agent-generated code as untrusted input that must be scanned before it merges -- the scrutiny you'd give code copied from a stranger's repo. Models reproduce the vulnerabilities in their training data and add new ones at volume, faster than humans review, so security has to shift left and run automatically.
TechGiving every agent its own identity and tightly scoped permissions -- answering not just whether a call can happen but who authorized the goal and who implemented it. The shift from impersonation (the agent assumes a user's identity) to delegation (the agent holds its own identity while acting on a user's behalf).
ProcessKnowing which code an agent wrote -- and recording what produced it (which agent, model, prompt or spec) -- so review, metrics, and compliance can treat it accordingly. Tag commits, PRs, or regions as agent-authored and keep that metadata with the code.
ProcessThe software lifecycle re-implemented as agent-native infrastructure -- the pipeline spine the rest of the platform plugs into. A spec enters at one end; reviewed, tested software comes out the other, with agents moving the work through every stage and humans defining intent and approving at gates.