Merge pull request #1625 from dgageot/coding-agent

Add a generalist coding agent

Author: dgageot

.dockerignore

@@ -8,4 +8,5 @@
 !./**/*.go
 !./**/*.txt
 !/pkg/config/default-agent.yaml
+!/pkg/config/coder-agent.yaml
 !/pkg/tui/styles/themes/*.yaml

cagent-schema.json

@@ -287,10 +287,6 @@
           "type": "boolean",
           "description": "Whether to add a 'description' parameter to tool calls, allowing the LLM to provide context about why it is calling a tool"
         },
-        "skills": {
-          "type": "boolean",
-          "description": "Enable skills discovery for this agent. When enabled, the agent loads skill definitions from well-known directories (~/.codex/skills, ~/.claude/skills, ~/.agents/skills, .claude/skills, .agents/skills) and includes them in the system prompt."
-        },
         "hooks": {
           "$ref": "#/definitions/HooksConfig",
           "description": "Lifecycle hooks for executing shell commands at various points in the agent's execution"

cmd/root/completion.go

@@ -30,6 +30,13 @@ func completeAlias(toComplete string) ([]string, cobra.ShellCompDirective) {
 
 	var candidates []string
 
+	// Add matching built-in agent names
+	for _, name := range config.BuiltinAgentNames() {
+		if strings.HasPrefix(name, toComplete) {
+			candidates = append(candidates, name+"\tbuilt-in agent")
+		}
+	}
+
 	// Add matching aliases
 	cfg, err := userconfig.Load()
 	if err == nil {

cmd/root/run.go

@@ -64,6 +64,7 @@ func newRunCmd() *cobra.Command {
 		Example: `  cagent run ./agent.yaml
   cagent run ./team.yaml --agent root
   cagent run # built-in default agent
+  cagent run coder # built-in coding agent
   cagent run ./echo.yaml "INSTRUCTIONS"
   echo "INSTRUCTIONS" | cagent run ./echo.yaml -
   cagent run ./agent.yaml --record  # Records session to auto-generated file`,

pkg/config/coder-agent.yaml

@@ -0,0 +1,144 @@
+models:
+  default:
+    provider: anthropic
+    model: claude-opus-4-6
+  haiku:
+    provider: anthropic
+    model: claude-haiku-4-5
+
+agents:
+  root:
+    model: default
+    description: Coding Agent
+    welcome_message: |
+      Ask anything... "Fix the tests", "Add this feature"
+    instruction: |
+      You are an expert software engineer. You help users understand, modify, debug, and improve codebases in any programming language or framework.
+
+      <workflow>
+      Follow this workflow for every code task:
+
+      1. **Understand**: Read the user's request carefully. Use tools to explore the codebase — search for files, read code, check project structure. Prefer tools over assumptions.
+
+      2. **Plan**: For non-trivial tasks, think through the approach before writing code. Identify which files need changes, what the dependencies are, and what could break.
+
+      3. **Implement**: Make the changes. Write clean, idiomatic code that matches the existing style of the project. Make the minimal set of changes needed.
+
+      4. **Validate**: Run the project's linter, type checker, or test suite to verify your changes. If something fails, fix it and re-validate. Do not consider the task done until validation passes.
+
+      5. **Summarize**: Briefly describe what you changed and why. Don't write summary files — just respond in the conversation.
+      </workflow>
+
+      <principles>
+      - Read before you write. Understand the existing code before modifying it.
+      - Make minimal, focused changes. Don't refactor unrelated code unless asked.
+      - Match the project's existing style, conventions, and patterns.
+      - Always validate your work by running tests or linters when available.
+      - Use the think tool to reason through complex problems step by step.
+      - Use the todo tool to track multi-step tasks and avoid losing context.
+      - Prefer tools over guessing. If you need to know something, look it up.
+      - When you don't know the project's build/test/lint commands, look for Makefiles, Taskfiles, package.json, Cargo.toml, pyproject.toml, or similar.
+      - Call multiple tools concurrently when the calls are independent.
+      </principles>
+
+      <code_quality>
+      - Write clean, self-documenting code. Add comments only when the "why" isn't obvious.
+      - Never add comments that restate what the code does.
+      - Handle errors properly. Don't swallow errors silently.
+      - Follow the language's idiomatic patterns and conventions.
+      - Keep functions focused and reasonably sized.
+      </code_quality>
+
+      <communication>
+      - Be direct. Skip filler phrases, excessive affirmations, and preamble.
+      - Don't show code you've already written to files unless the user asks.
+      - When you hit a genuine ambiguity, ask one clear question rather than guessing wrong.
+      - For complex tasks, briefly outline your plan before starting.
+      </communication>
+
+      <librarian>
+      You have access to a librarian sub-agent that can search the web and documentation.
+      Delegate to the librarian when you need:
+      - Documentation for an unfamiliar library, API, or framework
+      - Best practices or patterns you're not sure about
+      - Information about error messages or issues you can't resolve from context alone
+      Don't delegate for things you already know or can find in the local codebase.
+      </librarian>
+    skills: true
+    add_date: true
+    add_environment_info: true
+    add_prompt_files:
+      - AGENTS.md
+    sub_agents:
+      - librarian
+    toolsets:
+      - type: filesystem
+      - type: shell
+      - type: todo
+      - type: fetch
+    commands:
+      commit:
+        description: "Commit local changes with an appropriate message"
+        instruction: |
+          Based on the changes below, create a single commit with a clear, conventional commit message.
+
+          - Current git status: !shell(cmd="git status")
+          - Current diff: !shell(cmd="git diff HEAD")
+          - Current branch: !shell(cmd="git branch --show-current")
+
+          Stage all relevant changes and commit. Use a concise subject line and a body if the changes are non-trivial.
+      fix-lint:
+        description: "Detect and fix lint, type, or build errors"
+        instruction: |
+          Find and fix any lint, type-check, or build errors in this project.
+
+          1. Detect the project type and find the appropriate lint/build commands (check Makefile, Taskfile, package.json, Cargo.toml, pyproject.toml, etc.)
+          2. Run them and analyze the output
+          3. Fix every issue found
+          4. Re-run to confirm everything passes
+      simplify:
+        description: "Simplify local changes without removing features"
+        instruction: |
+          Look at the local changes and simplify the code and architecture without removing any functionality.
+
+          - Git diff: !shell(cmd="git diff HEAD")
+
+          Focus on making the code easier to read and maintain. Reduce complexity, remove duplication, improve naming.
+      init:
+        description: "Generate an AGENTS.md file for this project"
+        instruction: |
+          Create an AGENTS.md file for this project by inspecting the codebase.
+
+          Analyze the project structure and include:
+          1. **Development Commands**: Build, test, lint, and run commands
+          2. **Architecture Overview**: Key packages/modules, responsibilities, and interactions
+          3. **Code Style**: Patterns, error handling, naming conventions
+          4. **Testing**: How to run tests, patterns used, special setup
+          5. **Key Files**: Quick reference table of important files
+
+          Be concise. Focus on what an AI coding agent needs to work with this project effectively.
+      test:
+        description: "Run tests and fix any failures"
+        instruction: |
+          Run the project's test suite and fix any failures.
+
+          1. Detect the project type and find the test command
+          2. Run the tests
+          3. If any fail, analyze the failures, fix the code, and re-run
+          4. Continue until all tests pass
+
+  librarian:
+    model: haiku
+    description: Web Researcher
+    instruction: |
+      You search the web for documentation, articles, and technical references.
+
+      When given a query:
+      1. Use context7 to search library/framework documentation
+      2. Use fetch to read specific URLs when needed
+
+      A good source of information, available to agents, is https://deepwiki.com/.
+
+      Return focused, relevant information. Include source URLs. Don't pad your response — just provide what was asked for.
+    toolsets:
+      - type: fetch

pkg/config/resolve.go

@@ -19,6 +19,24 @@ import (
 //go:embed default-agent.yaml
 var defaultAgent []byte
 
+//go:embed coder-agent.yaml
+var coderAgent []byte
+
+// builtinAgents maps built-in agent names to their embedded YAML configurations.
+var builtinAgents = map[string][]byte{
+	"default": defaultAgent,
+	"coder":   coderAgent,
+}
+
+// BuiltinAgentNames returns the names of all built-in agents.
+func BuiltinAgentNames() []string {
+	names := make([]string, 0, len(builtinAgents))
+	for name := range builtinAgents {
+		names = append(names, name)
+	}
+	return names
+}
+
 // ResolveAlias resolves an agent reference and returns the alias if it exists and has options.
 // Returns nil if the reference is not an alias or doesn't have options.
 func ResolveAlias(agentFilename string) *userconfig.Alias {
@@ -69,9 +87,9 @@ func ResolveSources(agentsPath string, envProvider environment.Provider) (Source
 		return nil, err
 	}
 
-	if resolvedPath == "default" {
+	if data, ok := builtinAgents[resolvedPath]; ok {
 		return map[string]Source{
-			"default": NewBytesSource("default", defaultAgent),
+			resolvedPath: NewBytesSource(resolvedPath, data),
 		}, nil
 	}
 
@@ -122,8 +140,8 @@ func Resolve(agentFilename string, envProvider environment.Provider) (Source, er
 		return nil, err
 	}
 
-	if resolvedPath == "default" {
-		return NewBytesSource(resolvedPath, defaultAgent), nil
+	if data, ok := builtinAgents[resolvedPath]; ok {
+		return NewBytesSource(resolvedPath, data), nil
 	}
 
 	if IsURLReference(resolvedPath) {
@@ -149,9 +167,9 @@ func resolve(agentFilename string) (string, error) {
 		}
 	}
 
-	// "default" is either a user defined alias or the default (embedded) agent
-	if agentFilename == "default" {
-		return "default", nil
+	// Built-in agent names (e.g. "default", "coder") are either user defined aliases or embedded agents
+	if _, ok := builtinAgents[agentFilename]; ok {
+		return agentFilename, nil
 	}
 
 	// Don't convert OCI references or URLs to absolute paths

pkg/config/resolve_test.go

@@ -103,6 +103,15 @@ func TestResolveAgentFile_DefaultIsDefault(t *testing.T) {
 	assert.Equal(t, "default", resolved)
 }
 
+func TestResolveAgentFile_CoderIsCoder(t *testing.T) {
+	t.Parallel()
+
+	resolved, err := resolve("coder")
+
+	require.NoError(t, err)
+	assert.Equal(t, "coder", resolved)
+}
+
 func TestResolveAgentFile_ReplaceAliasWithActualFile(t *testing.T) {
 	home := t.TempDir()
 	t.Setenv("HOME", home)
@@ -307,6 +316,28 @@ func TestResolve_DefaultAliasOverride(t *testing.T) {
 	assert.Contains(t, string(data), "Custom agent")
 }
 
+func TestResolve_CoderBuiltinAgent(t *testing.T) {
+	t.Parallel()
+
+	source, err := Resolve("coder", nil)
+	require.NoError(t, err)
+	assert.Equal(t, "coder", source.Name())
+
+	// Verify it reads the embedded coder agent config
+	data, err := source.Read(t.Context())
+	require.NoError(t, err)
+	assert.Contains(t, string(data), "Coding Agent")
+}
+
+func TestBuiltinAgentNames(t *testing.T) {
+	t.Parallel()
+
+	names := BuiltinAgentNames()
+
+	assert.Contains(t, names, "default")
+	assert.Contains(t, names, "coder")
+}
+
 func TestResolve_DefaultAliasToOCIReference(t *testing.T) {
 	home := t.TempDir()
 	t.Setenv("HOME", home)