Coding agents in Kapso: the five pluggable implementers

kapso --list-agents

class CodingAgentInterface(ABC):
    def initialize(self, workspace: str) -> None:
        """Initialize for a specific workspace."""

    def generate_code(
        self,
        prompt: str,
        debug_mode: bool = False,
        timeout_seconds: Optional[float] = None,
    ) -> CodingResult:
        """Generate or modify code; timeout_seconds is the budget deadline."""

    def cleanup(self) -> None:
        """Clean up resources."""

    def get_cumulative_cost(self) -> float:
        """Return total cost accumulated."""

    def supports_native_git(self) -> bool:
        """Return True if agent handles its own commits."""

from kapso.execution.coding_agents.factory import CodingAgentFactory

config = CodingAgentFactory.build_config(
    agent_type="claude_code",
    model="claude-opus-5",
)

agent = CodingAgentFactory.create(config)
agent.initialize("/path/to/workspace")

result = agent.generate_code("Implement a sorting algorithm")
print(f"Files changed: {result.files_changed}")
print(f"Cost: ${result.cost:.4f}")

npm install -g @anthropic-ai/claude-code

coding_agent:
  type: "claude_code"
  model: "claude-opus-5"
  agent_specific:
    auth_mode: "oauth"
    claude_md_path: "CLAUDE.md"

coding_agent:
  type: "claude_code"
  model: "us.anthropic.claude-haiku-4-5-20251001-v1:0"
  agent_specific:
    auth_mode: "bedrock"
    aws_region: "us-east-1"

npm install -g @openai/codex
codex login

coding_agent:
  type: "codex"
  model: "gpt-5.6-sol"

coding_agent:
  type: "gemini"
  model: "gemini-2.5-flash"
  debug_model: "gemini-2.5-flash"

conda create -n openhands_env python=3.12
conda activate openhands_env
pip install openhands-ai litellm

coding_agent:
  type: "openhands"
  model: "gpt-4.1-mini"
  agent_specific:
    max_iterations: 30

coding_agent:
  type: "oss_claude_code"
  model: "accounts/fireworks/models/glm-5p2"

@dataclass
class CodingResult:
    success: bool           # Whether generation succeeded
    output: str             # Agent's response text
    files_changed: List[str]  # Modified files
    error: Optional[str]    # Error message if failed
    cost: float             # Cost in dollars
    commit_message: Optional[str]  # Agent-generated message
    metadata: Dict[str, Any]  # Agent-specific data

<code_changes_summary>Brief description of changes made</code_changes_summary>
<evaluation_script_path>kapso_evaluation/evaluate.py</evaluation_script_path>
<evaluation_output>Full output from running evaluation</evaluation_output>
<score>0.92</score>
<technical_difficulties>Anything that blocked or degraded the work</technical_difficulties>

I've implemented the random forest classifier. Here's what I did:

1. Created main.py with the classifier implementation
2. Added data loading and preprocessing
3. Created kapso_evaluation/evaluate.py to test accuracy

<code_changes_summary>Implemented random forest classifier with
GridSearchCV for hyperparameter tuning. Added cross-validation and
accuracy reporting.</code_changes_summary>
<evaluation_script_path>kapso_evaluation/evaluate.py</evaluation_script_path>
<evaluation_output>Loading data...
Training model...
Accuracy: 0.92</evaluation_output>
<score>0.92</score>
<technical_difficulties>none</technical_difficulties>

from kapso.execution.search_strategies.generic.feedback_generator.feedback_generator import (
    FeedbackGenerator,
)
from kapso.execution.coding_agents.factory import CodingAgentFactory

# Use gemini for feedback generation
config = CodingAgentFactory.build_config(
    agent_type="gemini",
    model="gemini-2.0-flash",
)

feedback_gen = FeedbackGenerator(coding_agent_config=config)

@dataclass
class CodingAgentConfig:
    agent_type: str         # "claude_code", "codex", etc.
    model: str              # Primary model
    debug_model: str        # Model for debugging
    workspace: str = ""     # Working directory
    use_git: bool = True    # Git integration
    agent_specific: Dict[str, Any] = field(default_factory=dict)

from kapso.execution.coding_agents.base import CodingAgentInterface, CodingResult
from kapso.execution.coding_agents.factory import CodingAgentFactory

class MyCustomAgent(CodingAgentInterface):
    def initialize(self, workspace: str) -> None:
        self.workspace = workspace
        # Setup agent

    def generate_code(self, prompt: str, debug_mode: bool = False) -> CodingResult:
        # Generate code
        model = self.config.debug_model if debug_mode else self.config.model

        # Call your API
        response = my_api.generate(prompt, model=model)

        # Track cost
        self._cumulative_cost += response.cost

        return CodingResult(
            success=True,
            output=response.text,
            files_changed=response.files,
            cost=response.cost,
        )

    def cleanup(self) -> None:
        # Clean up resources
        pass

    def supports_native_git(self) -> bool:
        return False  # Let ExperimentSession handle commits


CodingAgentFactory.register("my_custom_agent", MyCustomAgent)

def supports_native_git(self) -> bool:
    return False  # let ExperimentSession handle commits

def get_capabilities(self) -> Dict[str, bool]:
    return {
        "native_git": self.supports_native_git(),
        "sandbox": False,
        "planning_mode": False,
        "cost_tracking": True,
        "streaming": False,
    }