For most of 2024 and 2025, AI agents were exciting but hard to pin down.

The demos were genuinely impressive. Agents booking flights. Shopping for products. Using computers the way humans do, clicking through interfaces, filling out forms, navigating websites. Manus showed what a general-purpose AI agent could look like, handling market research, coding, and data analysis with minimal prompting. Meta acquired them last week for a reported $2 billion.

The ambition was clear. The question was always: how do you actually build these things reliably?

That question is getting answered. The answer is better architecture. Engineers started treating agents like real software. With patterns. With memory management. With boring things like error recovery.

Here's what that stack looks like.

The Layers

If you've built software before, this will feel familiar.

Models are the CPU. Large language models like Claude are great at reasoning and language. But on their own, they don't know how to do things. They lack memory, context management, workflows. A CPU is powerful too. It still needs an operating system.

Agents are the operating system. They sit on top of models and give them a runtime. They interpret goals. They decide which tools to use. They manage multi-step processes.

Skills are applications. Instead of building a custom agent for every task, you equip a general agent with specific capabilities. Like installing apps.

Orchestration tools coordinate teams. When one agent isn't enough, something needs to manage the group.

It's starting to look like regular software architecture. That's the point.

Claude Code: Proof the Architecture Works

One of the clearest examples of this thinking in production is Claude Code, Anthropic's command-line coding agent built by Boris Cherny.

The origin story is worth knowing. Cherny joined Anthropic in September 2024 and started prototyping with Claude through the terminal. The first version could tell him what music he was listening to via AppleScript. Cute, but not that useful. Then a colleague suggested giving it filesystem access.

"Claude exploring the filesystem was mindblowing to me because I'd never used any tool like this before."

That moment of discovery sparked the full project.

What's interesting about Claude Code's architecture is what they didn't build. No complex multi-agent orchestration. No elaborate scaffolding. Instead, a single-threaded master loop with a simple feedback cycle: gather context, take action, verify work, repeat.

Every time there's a new model release, the team deletes code. Simplicity is the point.

The result: most of Claude Code's codebase was written by Claude Code itself. Cherny estimates around 80% overall. He recently noted that 100% of his own contributions in the last month were written by Claude Code. The team picked technologies Claude already understood well, then let the model improve its own tooling iteratively.

This matters because it shows you don't always need a complex multi-agent system. Sometimes a well-designed single agent with the right architecture is enough. The CLI runs on your machine, executes bash commands directly, accesses your filesystem. No virtualization, no elaborate sandboxing. The model still runs on Anthropic's servers via API, but the agent harness is local.

The Claude Code SDK has since been renamed the Claude Agent SDK, reflecting Anthropic's broader vision. The same harness that powers a coding agent can power many other kinds of agents.

Skills: Modular Capabilities

Anthropic also published something called Agent Skills as an open standard.

A skill is a folder. Inside, there's a SKILL.md file describing what it does. There might be reference docs, scripts, or examples.

The clever part: the agent doesn't load everything at once.

At startup, Claude only sees metadata. Name and description. Enough to know what's available. When a task needs a particular skill, Claude loads the instructions on demand.

Like a table of contents. You scan what's there, then read the chapter you need.

This solves a real problem. Language models have context limits. If you stuff every possible instruction into the prompt, you run out of room. Skills let agents stay general but pick up specific expertise when needed.

Skills can also include executable code. If something has a deterministic solution (like extracting form fields from a PDF), the agent runs a script instead of figuring it out from scratch. More reliable.

The open standard part matters too. Different platforms can share the same skills. That's a step toward tools that work across ecosystems.

Gas Town: Coordinating Multiple Agents

One skilled agent can handle a lot. But some problems need a team.

Gas Town is a framework for managing multiple Claude agents working in parallel. It treats agents as persistent workers, not throwaway chat sessions.

The system has roles:

•A Mayor coordinates across the project
•A Witness monitors agent health
•A Refinery handles merging code
•Polecats are individual workers executing tasks

Each agent has a queue. Work comes in, they run it, results get saved to a git-backed ledger.

If an agent crashes mid-task, another can pick up where it left off. That's crash recovery for AI.

Gas Town scales to 20-30 coordinated agents comfortably. That's different from running a few agents and hoping they don't step on each other.

Memory That Sticks Around

Underneath Gas Town is Beads, a git-versioned task tracker designed for agents.

Tasks are stored as entries with hierarchical IDs. Epics, tasks, sub-tasks. Dependencies. History.

This turns agents from chat sessions into workers with actual memory.

The insight: if agent state only lives in conversation history, you lose everything when the session ends. Beads externalizes that. Work has identity. It persists.

What's Actually New

Several things are coming together:

•Production-tested architectures like Claude Code prove single-agent systems can work at scale with the right design
•Skills package expertise so agents can load capabilities on demand
•Memory systems like Beads give agents state that survives across sessions
•Orchestration lets multiple agents work together without chaos

None of these ideas are revolutionary on their own. Modular code, persistent storage, job queues. We've had these patterns for decades.

What's new is applying them to AI agents systematically.

How Pulse Is Watching This

We build a financial OS, not agents. But this space matters to us.

Pulse already uses AI for market analysis, daily briefs, and portfolio insights. Right now, that's mostly request-response. You ask, we answer. But the patterns emerging in agent architecture point toward something more proactive.

Imagine an agent that notices your portfolio drifted from your target allocation. Or surfaces a relevant SEC filing before you knew to look. Or connects a macro trend to a specific holding you own.

Doing the legwork so you can make better decisions faster.

We're not building autonomous trading bots. That's not what Pulse is for. But the infrastructure being built for agents, the memory systems, the orchestration layers, the modular capabilities, that's relevant to anyone building intelligent software.

We're paying attention.

Where This Is Headed

2026 feels like the year agents become something you can actually build on.

They're becoming proper engineering.

Claude Code showed a single agent with good architecture can be powerful. Skills make agents adaptable. Orchestration makes them manageable at scale. Memory makes them reliable.

The question used to be "can agents do this?" Now it's "how do we build agents that do this well?"

That's a better question.