Argent

The Problem

Do not make one agent understand every project. Let every project speak for itself.

AI coding agents are powerful, but they work around the development environment instead of inside it.

They see files. They can run commands. Sometimes they can open a browser or call a tool. But they do not naturally understand which services are running, which localhost port belongs to which project, which checks are authoritative, which sibling repo owns a concern, which sandbox is safe, or when a human needs to take over.

The workspace is implicit. Humans know the web app runs on one port, Storybook on another, API fixtures in a third process, and the generated client should not be edited by hand. Agents discover that by trial, logs, and luck.

Every agent starts from zero. Claude Code, Codex, Cursor, internal wrappers, and local models each build their own partial picture of the project. The useful operational state does not survive as shared runtime knowledge.

Human attention is treated like a console prompt. The system interrupts too often for noise and not reliably enough for judgment, approval, security-sensitive actions, or repeated failure.

The Workarounds Leak

Teams patch the gap with scripts, READMEs, terminal tabs, and prompt instructions.

AGENTS.md helps, but it is not a runtime. It can tell an agent what the rules are. It cannot keep a service alive, assign work across projects, route messages between actors, or record what actually happened during a task.

tmux keeps sessions alive, but it does not understand work.A pane can hold a dev server or an agent. It cannot know that the web service is ready, that tests regressed, or that a reviewer agent should take the next pass.

Docker isolates execution, but it is not coordination.Containers can make work repeatable. They do not describe project ownership, named services, task state, memory promotion, or human handoff.

The missing layer is not another coding agent. It is a workspace substrate that gives the agents you already use a shared model of the environment they are working in.

What Argent Does

Argent turns a developer's local machine and project graph into an agent-readable workspace.

Active services, deterministic local URLs, tests, Storybook, static fixture servers, Docker sandboxes, tmux sessions, project context, skills, task state, and human handoff are modeled as capabilities. Existing agents can call those capabilities through MCP, CLI, local API, or project-native wrappers.

workspace.status()
workspace.service.url("web")
workspace.context.query(...)
workspace.skill.invoke(...)
workspace.sandbox.create(...)
workspace.handoff.request(...)

The agent remains the reasoning worker. Argent supplies the work environment: what exists, what is running, what is allowed, what changed, what failed, what needs review, and what should be promoted into durable knowledge.

Project Contracts

Argent starts from the project, not from a global agent folder.

Each project declares how agents should operate inside it: identity, ownership, related projects, Context Engine configuration, Skillex scopes, services, checks, sandbox policies, agent roles, approval rules, and memory promotion rules. That contract can live in AGENTS.md, argent.yaml, or a project-local configuration file.

The point is boundary discipline. An agent working in one repo should not wander into a sibling repo because it found a path. It should ask Argent which project owns the concern and coordinate through that project's declared interface.

Services and Routes

Agents should not invent localhost ports.

Argent models services by name: web, storybook,api, assets, docs,mock-s3, whatever the project declares. Those services can map to host processes, Docker containers, static file servers, remote targets, or Caddy routes.

Instead of guessing whether localhost:5173 is the right thing today, an agent asks for workspace.service.url("web"). The route is deterministic. The project contract owns the mapping. The runtime observes readiness and failure.

Sandboxes and Processes

Real development work needs multiple lanes.

Some tasks can run directly on the host. Some should run in a scratch workspace. Some need a Docker container, a devcontainer, a worktree, or a networkless sandbox. Argent tracks those lanes, the processes inside them, the task that owns them, and the human-visible pane or attach target when one exists.

This makes agent work observable without making it noisy. The runtime can know that a watcher failed after the last change, a dev server crashed unexpectedly, a test runner is still healthy, or a human can attach directly to the live session.

Memory and Provenance

Runtime memory is not project memory.

Argent records operational truth: messages, task events, process events, handoffs, check results, changed files, review state, and memory proposals. It stores what happened and what is true now in a local runtime ledger.

Context Engine owns durable project knowledge. Argent can produce evidence and validated findings, but promotion into durable memory should be explicit, source-backed, and reviewable.

Human Handoff

Argent treats human attention as a first-class resource.

Routine work stays hidden. Meaningful state changes are surfaced: a service is ready, a check started failing, a reviewer requested revision, a cross-project task touched two repos. Direct human interaction is reserved for judgment, approval, intervention, destructive commands, migrations, repeated failure, or ambiguous product behavior.

A handoff is structured. It includes the reason, current task, project, state, evidence, attach target, recommended action, and expected resume condition. The human is not just dropped into a terminal and asked to guess what matters.

The Ecosystem Layer

Argent sits above project-local tools and below the agent frontend.

Context Engine = project intelligence
Skillex        = skill/capability intelligence
Argent         = work/runtime intelligence
Agents         = replaceable reasoning/action workers
Human          = authority, judgment, direction

Context Engine tells Argent what the project means. Skillex tells Argent what capabilities apply here. Argent decides which actor should do what next, in which environment, with which services, checks, sandbox, and handoff rules.

Keep your agents. Keep your project conventions. Give them a smarter workspace.

Philosophy

The next major improvement in AI-assisted development will not come only from smarter models.

It will come from better runtime structure around those models: durable state, project context, service awareness, sandboxing, feedback loops, coordination, and human control. Argent makes the environment smarter, so the agents working inside it can be more useful without becoming more dangerous.