What is an agent?

The industry has several definitions.

Gartner calls it "a software entity that perceives its environment, makes decisions, takes actions, and works toward goals." They warn of "agent washing"—vendors calling assistants "agents" when they're just chatbots with extra steps.

BuiltABot distinguishes agents from chatbots: chatbots "reset context per session" and handle simple Q&A; agents "maintain context across conversations, reason through multi-step workflows, and take actions via integrations."

Google's A2A Protocol defines an agent as "an independent software entity" that:

Exposes capabilities via an Agent Card (JSON metadata)
Communicates via HTTP/JSON-RPC endpoints
Handles tasks, provides status updates, returns artifacts

Key concept from the spec: agents are "opaque"—they don't share internal state with other agents.

My definition:

An agent is a computer system that can be controlled with natural language and uses inference to interpret inputs and make policy decisions. Everything else—memory, tools, planning—is implementation detail.

Concerns

These are the functional and non-functional requirements for a production agent system.

Functional

Concern	What it means
Task management	Break down goals into subtasks, track progress, handle interruptions, stay within cost and time budgets
Memory & context	Retain information across sessions, query knowledge bases, manage context
Tool integration	Call functions according to inferencing results, and provide the results in subsequent inferencing calls
Human-in-the-loop	Escalate when uncertain, support approval workflows
Guardrails	Prevent hallucination, prompt injection, unauthorized actions
Verification	Agentic feedback on outputs—without this, nothing scales

Non-Functional

Concern	What it means
Reliability	Uptime, graceful failure, recovery
Performance	Response latency, throughput
Scalability	Handle more users, agents, tools without degradation
Security	Encryption, access control, threat resistance
Compliance	GDPR, HIPAA, audit trails
Cost	Delegation budgets prevent runaway spend. RAG is expensive—fine-tune on your knowledge base to capitalize on it
Throughput	You will get rate-limited on OpenAI. Plan for throttling, retries, fallback models
Auditing	What completion happened, when, why, what tool call resulted. Without this, debugging is impossible

The stack

These are the tools I'm using to build agents.

Layer	Tool	Purpose
Orchestration	Temporal	Workflows, activities, scheduling, retries
Tool protocol	MCP	Standard way for agents to call tools
Agent protocol	A2A	Standard way for agents to talk to agents
Knowledge base	Postgres + pgvector	Vectors, full-text search, JSONB, graphs (via Apache AGE)
Streaming	Redis or NATS	Pub/sub for token streaming to browser
Backend	Go or TypeScript	HTTP/2, SSE, websockets
Frontend	Preact + nanostores	Chat UI, streaming, markdown rendering
Sandboxes	agent-sandbox via K8s	Code execution
Collaboration	Yjs	CRDT-based docs, kanban, shared state

Architecture

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   Browser   │◄───►│   Backend   │◄───►│  Temporal   │
│  (Preact)   │ SSE │  (Go/TS)    │     │  (Workflows)│
└─────────────┘     └─────────────┘     └──────┬──────┘
                                               │
                    ┌──────────────────────────┼──────────────────────────┐
                    │                          │                          │
              ┌─────▼─────┐            ┌───────▼───────┐          ┌───────▼───────┐
              │    LLM    │            │  MCP Servers  │          │   Knowledge   │
              │ (Ollama)  │            │   (Tools)     │          │     Base      │
              └───────────┘            └───────────────┘          │  (Postgres)   │
                                                                  └───────────────┘