Last week, OpenAI’s new Astra model introduced a reasoning technique called “opaque recurrence” - and AI safety researchers have been unsettled by it ever since. That’s a useful reminder that AI’s vocabulary isn’t just growing; it’s actively mattering.

The Terms Everyone Is Using (And What They Actually Mean)

AGI remains one of the most contested terms in the field, and the disagreement starts at the top. OpenAI CEO Sam Altman has described AGI as “the equivalent of a median human that you could hire as a co-worker.” OpenAI’s own charter defines it differently - as “highly autonomous systems that outperform humans at most economically valuable work.” Google DeepMind takes a third position, framing AGI as “AI that’s at least as capable as humans at most cognitive tasks.” These are not minor semantic differences; they reflect genuinely divergent assumptions about what the benchmark for human-level intelligence even is.

AI agents sit at the other end of the abstraction spectrum - more concrete in function, if not always in definition. The basic concept is an autonomous system that can perform multistep tasks on a user’s behalf: filing expenses, booking a restaurant, writing and maintaining code. Unlike a standard chatbot that responds to a single prompt, an agent may draw on multiple AI systems in sequence to complete a goal. The catch, as the field currently stands, is that the infrastructure required to reliably deliver on those capabilities is still being built out - meaning “AI agent” can mean meaningfully different things depending on who’s using the term.

API endpoints are often described as the hidden control surfaces of software. They’re the interfaces that allow one program to interact with another - a way for an AI agent, for instance, to control a third-party service without a human manually operating each step. Most smart home devices and connected platforms expose these endpoints, even if everyday users never encounter them directly. As AI agents become more capable, they are increasingly able to identify and use these endpoints autonomously, which creates powerful automation possibilities but also introduces risks that weren’t relevant when humans were the only ones pressing those buttons.

Compute is the shorthand the industry uses for the raw computational resources that make AI systems run - GPUs, CPUs, TPUs, and the broader infrastructure stack underneath them. It’s both a technical descriptor and an economic one: access to compute has become a primary constraint on who can train large models and how quickly. When you hear about AI labs raising hundreds of millions of dollars, a substantial portion of that money is going toward compute.

Reasoning, Learning, and the Mechanics Underneath

Chain-of-thought reasoning is the technique that lets large language models work through multi-step problems rather than reaching for an immediate answer. The analogy is straightforward: some questions you can answer in your head, but others require writing things down. A classic logic problem - say, a farmer has chickens and cows totaling 40 heads and 120 legs, how many of each? - benefits from intermediate steps rather than a direct guess. In an AI context, chain-of-thought prompting breaks a problem into smaller sub-steps, which tends to produce more accurate results, particularly in logic and coding tasks. The tradeoff is latency: chain-of-thought responses take longer to generate.

Reasoning models are large language models that have been specifically optimized for chain-of-thought thinking through reinforcement learning. They’re not a separate architecture so much as a fine-tuned variant trained to slow down and work through problems systematically. OpenAI’s o-series models are the most cited examples of this approach, though the broader category now includes models from several labs. The term “opaque recurrence” - the technique in OpenAI’s Astra model that’s drawing scrutiny from safety researchers - appears to be a specific implementation of this kind of internal reasoning process, though the details of what makes it distinct (and concerning) are still being worked out publicly.

Deep learning is the foundational technique underlying most modern AI systems, including large language models. It refers to training artificial neural networks with many layers on large datasets, allowing the model to learn patterns without explicit programming for each one. The “deep” in deep learning refers to the number of layers in the network - more layers generally mean the model can represent more complex abstractions. While the term dates back decades, it became the dominant framework for AI development following a series of benchmark breakthroughs in the early 2010s.

Coding agents are a specialized application of the AI agent concept, targeted at software development workflows. Rather than suggesting code snippets for a developer to review and insert manually, a coding agent can write, test, and debug code autonomously - iterating through the kind of trial-and-error cycle that typically consumes significant developer time. These agents can operate across entire codebases, identify bugs, run test suites, and push fixes with limited human involvement. The analogy that gets used frequently is an intern who never sleeps - capable and fast, but still requiring human review before anything goes to production.

Why the Vocabulary Keeps Expanding

The speed at which AI terminology proliferates isn’t arbitrary. Each new term tends to mark either a genuine technical development - a new architecture, a new training method, a new failure mode - or a product-marketing decision by a lab trying to differentiate something it has built. “Opaque recurrence” falling into the first category would explain why safety researchers are paying close attention rather than dismissing it as branding.

The definitional instability around terms like AGI, meanwhile, has real downstream consequences. When OpenAI’s charter triggers specific governance thresholds upon reaching AGI, the definition the board uses determines when those thresholds activate. For investors, regulators, and researchers, knowing which version of a term a company is working from is not a semantic exercise - it’s a due diligence requirement.