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.
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.
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.
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 experience | ChatGPT + Codex | Chat and agent inside a tightly integrated ecosystem. |
| Claude plus a terminal agent | Claude Pro + Claude Code | A direct route to using Claude as an agent. |
| To try several models | OpenCode + Go | An open harness with a changing selection of models. |
| To experiment with APIs and providers | OpenRouter | One API for comparing models and providers. |
| To learn local inference | Ollama / LM Studio + local model | More 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.
