AI · Agentic Systems

From ChatGPT to agents: what you need to understand to get started today

Models, providers, APIs, subscriptions and harnesses can make getting started with agents look more complicated than it really is. This is the map I wish I had when I started experimenting with them.

ChatGPT hardly needs an introduction anymore. The jump starts to feel much larger once you leave the chat interface and see someone open a terminal, launch Codex, Claude Code or OpenCode, and let the model work directly on a real project. Then terms such as models, providers, APIs, MCP, skills and local inference start appearing, and it is easy to think you need to understand the whole ecosystem before you can begin.

I got into this space in much the same way, trying models, harnesses, APIs and eventually local models. Over time I understood why two people can say they are using “the same model” and still have very different experiences: the model is only one part of the system around it.

This is the map I wish I had then. It is aimed at someone who already knows ChatGPT and wants to start using agents without first building their own infrastructure or chasing every new tool that appears.

From talking to a chatbot to giving work to an agent

A chat interface can already summarise documents, interpret screenshots, search for information and help with code. The practical difference becomes clearer when the model can work directly on an environment.

Imagine a folder with hundreds of messy files. With a chatbot I can explain the problem and ask it to write a script. Then I have to copy it, run it, bring the errors back and repeat the process. An agent with access to that folder and a terminal can inspect it, write the script, run it and check the result itself.

The same applies to development. Instead of pasting a function and asking why it fails, I can give the agent access to the repository and ask it to locate the problem. It can follow references, inspect other files, run tests and validate the change.

The simplest useful model is a language model inside a loop with access to tools:

receive context → decide what to do → use a tool → observe the result → decide again.

Model capability still matters, but so do what the model can observe and which actions the system lets it perform.

Chat and agent interaction A chat can return a response from a model. An agent harness gives the model access to files, a terminal and tools, then returns observations so it can decide what to do next. Both experiences can use the same model. User Model Response User Harness Model Context Tools and environment Files · TerminalTools / Web provides access Tool call Observation Chat and agent interaction A chat can return a response from a model. An agent harness gives the model access to files, a terminal and tools, then returns observations so it can decide what to do next. Both experiences can use the same model. User Model Response User Harness Model Tools and environment Files · TerminalTools / Web Tool call Observation via harness
Moving from a chatbot to an agent does not necessarily require changing the model. The main difference is the surrounding context, tools and ability to act.

Model, provider, harness and environment

Products such as ChatGPT hide most of these layers. With more open tools, it helps to separate them mentally:

model → provider → harness → tools and environment

The model

GPT, Claude, Gemini, Qwen and DeepSeek are model families. The model receives the context prepared by the system and generates the next output, which may be text, code or a request to use a tool.

At a high level, proprietary models from companies such as OpenAI, Anthropic and Google coexist with a large open-weight ecosystem that includes Qwen, DeepSeek, GLM, Kimi and others. Both groups now include models that can code, reason and use tools. That distinction is useful for orientation, but it does not tell you which model will fit a particular job best.

For this map, you do not need to start with parameters or model architecture either. The important point is that the model receives whatever the system has placed in context and generates the next step. Everything around that call belongs to other layers.

The provider

The company that creates a model and the company that runs it for you do not have to be the same. A model can be served by different providers, with meaningful differences in speed, availability, features and price.

OpenRouter makes that separation especially visible because it exposes many models and providers behind one API. The same model can differ in latency, throughput, availability or feature support depending on the endpoint. It is a good reminder that saying “I use this model” still leaves out an important part of how you are using it.

The harness

Codex, Claude Code and OpenCode are examples of harnesses. The definition that is most useful to me is simple: it is the software that puts the model to work.

The harness prepares context, exposes tools, executes the actions requested by the model and feeds the results back into the next step of the loop. It can also manage permissions, session history and context compaction. That layer explains why the same model can feel quite different inside two agents.

An integrated stack such as GPT with Codex or Claude with Claude Code can optimise several layers together. An open harness such as OpenCode lets you keep a similar workflow while changing model or provider. Interface matters too: some people prefer a TUI, while others work better with visible sessions and diffs. Over time I stopped asking only “which model are you using?” and started asking “where are you using it?” as well.

Model, provider, harness and environment The model receives inference through a provider. A harness uses that model and connects it to an execution environment. The user gives work to the harness rather than adding another layer. Model GPT · Claude · QwenDeepSeek Provider Direct providerRouter / hostingLocal runtime Harness Codex · Claude CodeOpenCode Environment Filesystem · terminalGit · browser · tools served by used by acts on User Task Model, provider, harness and environment The model receives inference through a provider. A harness uses that model and connects it to an execution environment. The user gives work to the harness rather than adding another layer. Model GPT · Claude · QwenDeepSeek Provider Direct providerRouter / hostingLocal runtime Harness Codex · Claude CodeOpenCode Environment Filesystem · terminalGit · browser · tools User served by used by acts on
Saying which model we use only describes one piece. The provider determines how we receive the inference, while the harness connects the model to an environment where it can act.

Subscription, API or local

The next decision is how to access the model. For a first map, I would reduce the options to three: subscription, API or local execution.

Subscription

A subscription is usually the easiest way to experiment because the cost is predictable. While learning, it is easy to define a task badly and discover that the agent has read half a repository for no reason, or simply spend an afternoon trying different workflows. A fixed fee gives you room to make those mistakes without turning every experiment into a bill.

You still have limits and usage rules. A subscription is not an unlimited API either, but for a first experience it is the simplest way to find out whether working with agents is actually useful to you.

API

With an API, you normally pay for model usage. The unit you will see constantly is the token: there are tokens you send and tokens the model generates. A long conversation or session may also reprocess instructions, history and previous results.

This matters especially with agents because one user request can trigger many inference calls. The model reads context, requests a tool, receives the result and decides again. A long run can accumulate far more usage than the message that started it.

An API makes sense when you want to integrate models into an application, automate tasks from CI or a backend, or need more control over data, spend and deployment. As a first mental model, I keep this distinction: a subscription is mainly designed for you to use a product. An API is designed for software to consume a service.

If you want to try many models through one integration, a router such as OpenRouter is particularly convenient.

Local

The third option is to run the model on your own hardware with a runtime such as Ollama, LM Studio or llama.cpp. You gain control over the runtime and over which data leaves your environment, but you also take on the memory and performance problems of local inference.

In my case, getting an experience I liked from a 27B Qwen model on a 16 GB RTX 5070 Ti meant trying different quantisations, tuning the KV cache and measuring performance before I even started the agentic test I wanted to run. I cover that in more detail in my article on Qwen3.8-27B with OpenCode.

That friction made sense because I also wanted to learn local inference. If your goal is to learn agents, I would start with whichever path keeps your attention on the task.

Three ways to provide inference to one agent Subscription, API and local execution are alternative ways to provide inference. They converge on the same harness and model rather than defining different kinds of agents. Subscription Predictable costUsage limitsEasy experimentation API Pay per useProgrammableAutomation / integration Local Your hardwareMore controlMore setup Harness One agent experiencefor any access route Model Inference Three ways to provide inference to one agent Subscription, API and local execution are alternative ways to provide inference. They converge on the same harness and model rather than defining different kinds of agents. Subscription Predictable costUsage limitsEasy experimentation API Pay per useProgrammableAutomation / integration Local Your hardwareMore controlMore setup Harness One agent experiencefor any access route Model Inference
Subscription, API and local execution are three different ways of supplying inference to an agent. Each changes cost, friction and control.

What I would try first

I would start with a project you can afford to break and a task you understand well enough to judge the result. That lets you watch how the agent inspects the environment, what it decides to change and how it reacts when something fails without making your most important repository the first experiment. It might be a folder you want to organise, a small personal project or a bug in a repository you already know.

The important part is that the task forces the agent to work with the environment and gives it a clear way to verify completion. An instruction like this is much more useful than “improve this project”:

Review how these pages are being generated. I want to remove this duplication without changing the public routes. Before changing anything, identify where it happens, and then run the existing tests and the build.

In practice, explaining the goal, constraints and validation has been more useful to me than trying to build a huge prompt for every task.

Context during an agentic session

An agent that has been working for a while no longer has only our latest message. Its context may include project instructions, files it has read, tool definitions, command results and part of the session history. All of that takes space and shapes the next decisions.

Context engineering is the work of deciding which information the model needs at each point. Some context may stay present throughout the session, while other information is retrieved only when needed. Filling the context with documentation “just in case” can also make the useful signal harder to find.

Long sessions introduce problems such as compaction and loss of relevant information. They make much more sense once you have actually watched a session degrade as it grows. I cover that layer in more detail in the Context Engineering Note.

Choosing models for your own workflow

The market moves too quickly for a model ranking to remain useful for long. Benchmarks help, but an aggregate score does not know whether your workflow cares most about quality, speed, cost, context, tool use or model policy.

I prefer a small eval of my own: pick two or three models that make sense and give them the same real task. Then compare which one needs less intervention, understands the objective better, finishes fast enough and costs an acceptable amount. A repetitive subagent may be better served by a cheaper, faster model. A difficult review may justify a more capable one.

That usually tells me more than chasing whichever model sits at the top of a general leaderboard that week.

A particularly awkward case: cybersecurity

There is another variable in my case because I work in offensive security. Model safety policies can have a noticeable effect on the workflow when the task involves exploitation, vulnerability analysis or actions that would be abusive outside an authorised environment.

OpenAI has Daybreak / Trusted Access for Cyber, a programme for security professionals and organisations that can reduce certain refusals in authorised workflows. Its access levels cover work ranging from defensive use to pentesting and exploit validation under additional requirements. Even so, I still encounter sessions where part of the friction is establishing the context of the work.

In other tests, models such as GLM or DeepSeek have been capable enough for the task and have given me a more direct experience. For me, that makes model policy another practical selection criterion alongside capability, speed and cost.

What I would recommend right now

This part will age quickly, so I would treat it explicitly as an October 2026 snapshot.

If you want…I would start with…Why
The most integrated experienceChatGPT + CodexChat and agent inside a tightly integrated ecosystem.
Claude plus a terminal agentClaude Pro + Claude CodeA direct route to using Claude as an agent.
To try several modelsOpenCode + GoAn open harness with a changing selection of models.
To experiment with APIs and providersOpenRouterOne API for comparing models and providers.
To learn local inferenceOllama / LM Studio + local modelMore control, in exchange for managing the hardware and runtime yourself.

For a first general experience, I would probably choose ChatGPT + Codex because the separation between thinking and execution fits the way I work. I can use chat to discuss an idea, research it and refine requirements, then move to Codex when it is time to work on files or a repository. That has become my normal pattern with these tools: discuss in chat → implement with the agent.

Start with the smallest useful setup

It is easy to spend more time preparing an agent than using it. For me the starting point should be one model, one harness, one project you can afford to break and one real task.

From there, add pieces when they solve a concrete problem. If you keep repeating a procedure, a skill may make sense. If you need to connect an external tool, MCP may become useful. If you want to switch models or providers constantly, a router starts to earn its place. If privacy or learning inference becomes the goal, then the extra complexity of a local model may be worth it.

That order has been much more useful to me than copying a complex architecture before I know what problem it is supposed to solve.

Final conceptual map for getting started with agents, built around a simple central path and optional components around it.

A simple entry map for getting started with agents: one model, one harness and one real task. Everything else is an optional layer that makes sense when a concrete problem appears.