KokoAI Academy · Advanced implementation
OpenAI Developer
Eight original KokoAI Academy engineering domains covering runtime ownership, server integration, context contracts, tools, state, Codex delivery, evaluation and production controls. Includes offline labs, public practice and a synthetic support-resolution capstone. Estimated domain times are planning estimates; this is practice-only educational material.
Start the first domainIndependent KokoAI training · Practice and assessment status
Original Koko educational design, not an OpenAI-issued certification or a claim of equivalence to any provider credential. Public questions are formative practice. Private forms are held-out candidates requiring independent review and calibration; no passing score, readiness probability or credential is established. Browser progress and self-report are study aids, not trusted scoring evidence. Transcripts are authored; rendered audio and Watch media require separate production and review.
Prerequisites, outcomes and downloads
Bring this experience
- Working knowledge of Python or TypeScript, HTTP/JSON and automated testing.
- Ability to read authentication/authorization code, version-controlled diffs and database transaction semantics.
- No paid provider account or API key is needed for the offline curriculum; optional live integration is a separate authorized exercise.
What you will be able to do
- Translate application requirements into independently testable quality, control and operating contracts.
- Select and implement an appropriate OpenAI integration while preserving application-owned authority.
- Build typed, scoped, evidence-grounded tools and resumable workflows with bounded execution.
- Use Codex with repository instructions, enforced environment boundaries and reproducible review evidence.
- Evaluate and debug behavior using frozen datasets, redacted traces and honest resource measurements.
- Defend a reversible release with deterministic security gates and operational recovery evidence.
Domain 1 of 8 · Application requirements and OpenAI platform selection
DEV-1 · About 150 minutes suggested
Application requirements and OpenAI platform selection
Turn product requests into testable contracts and select an execution ownership model.
Your objectives
- DEV-1-O1: Write acceptance criteria that separate model quality, deterministic controls, and operational constraints.
- DEV-1-O2: Compare Responses, Agents SDK, and managed Agents API using execution, state, and integration ownership.
- DEV-1-O3: Defend a runtime decision with a failure experiment and explicit responsibilities that remain application-owned.
Specify behavior before selecting a model
The useful mental model is a contract between an uncertain proposal generator and a deterministic application. Begin with a user outcome, an actor, the evidence available, and the action the system may take. For a synthetic support ticket, the outcome might be a policy-grounded recommendation with no refund submitted until a supervisor approves the exact proposal. Convert this into observable assertions: evidence identifiers must resolve to authorized policy versions; missing evidence produces an escalation; denied approval produces zero action-service writes. These assertions differ from stylistic preferences such as friendly wording. A convincing response does not demonstrate that an action was authorized or executed correctly.
Divide acceptance evidence into three columns. Quality evidence measures whether recommendations answer the ticket and use the right policy. Control evidence tests invariants such as tenancy and at-most-once submission under replay. Operational evidence measures elapsed time, dependency failures, and spend against a declared workload. A worked requirement reads: given an expired approval token, return an approval-required state and make no submission call, even when the model says the refund is urgent. A competing approach is to ask the model to decide whether approval is necessary. That approach mixes authorization with persuasion and cannot prove the invariant. Use synthetic cases first, record assumptions, and avoid fabricated performance numbers.
- Agents: runtime selection · Checked 2026-11-17
- Safety best practices · Checked 2026-11-17
Choose an execution ownership model
OpenAI currently documents three different starting points. Direct Responses integration exposes model responses and tools while the application controls its integration and, when needed, its loop. The Agents SDK runs in the application and supplies a runner with reusable agents, tools, and handoffs. The managed Agents API runs a Codex harness managed by OpenAI and saves progress across tasks. These names do not describe interchangeable wrappers around a single session resource. An SDK session, an Agents API session, a Responses conversation, and a sandbox have different lifecycles. List where each resource lives, who can read it, how it is resumed, and how it is deleted.
Consider two implementations of the support assistant. A small synchronous recommendation endpoint with one retrieval call may need only Responses and an application-owned state machine. A code-first workflow with several specialized tools and explicit handoffs may benefit from the SDK runner. A long-running task that benefits from a managed Codex harness may warrant the Agents API after validating its integration and execution requirements. Avoid choosing from feature count alone. Compare deployment requirements, state portability, pause/resume behavior, observability, and cleanup obligations. Managed execution reduces some infrastructure work; it does not grant business permission to issue refunds or eliminate the application's need to validate tool inputs and user identity.
- Agents: runtime selection · Checked 2026-11-17
- Agents API architecture · Checked 2026-11-17
- Running agents · Checked 2026-11-17
Make the decision falsifiable
Write an architecture decision record with workload assumptions, selected runtime, rejected alternatives, and a condition that would reverse the choice. For example, choose an SDK application when existing services require in-process adapters and application-owned deployment. Reject a custom Responses loop if the team cannot maintain handoff and interruption logic safely; reject managed execution if a required integration boundary cannot yet be demonstrated. The decision is provisional until a small experiment exercises the highest-risk behavior. A happy-path transcript tests presentation, while a timeout during approval resumption tests the ownership decision that actually matters. Keep the experiment narrow enough to isolate the uncertain boundary.
For the worked experiment, save a proposal identifier, its evidence-version digest, and approval state in an application store. Interrupt execution before submission, then resume with an expired approval and confirm zero effects. Repeat with a valid approval and a duplicate resume, confirming one effect with a stable operation key. These are Koko educational controls, not promises that any runtime automatically implements them. Record which adapter would call the provider and keep offline results labeled as fixture results. Review the chosen runtime's current guide before adding live integration. The final deliverable is a defensible choice with test evidence and named owners, rather than a vendor comparison chart with unsupported checkmarks.
- Agents: runtime selection · Checked 2026-11-17
- Conversation state · Checked 2026-11-17
- Production best practices · Checked 2026-11-17
