Agenter: Call Coding Agents From Your Code

AI coding agents are incredible. Claude Code, Codex, OpenHands – they can understand codebases, write features, fix bugs, test your code, and generate documentation. Even so, they’re all designed for, and ultimately restricted by, one interaction mode: a human in front of a terminal.

What if you want to embed coding agents in your applications?

The Vision: Coding Agents as Infrastructure

Imagine building systems where coding agents are just like any another service that you call:

• Self-healing deployments. Your monitoring tools detect a bug in production. An agent diagnoses the issue, writes a fix, and opens a PR, all completely automatically.
• Automated code reviews. Before merging, an agent validates an implementation against specs, checks for edge cases, and suggests improvements.
• IDE plugins. Your editor doesn’t just highlight errors – it fixes them in place by calling a coding agent with full project context.
• CI pipelines that adapt. Tests fail? An agent analyzes the failure and patches the code.

The common thread: you need coding agents which are callable from within code itself, not just a terminal.

In the agentic era of software development, treating coding agents as interactive terminal tools was just the beginning. The real power comes when they become fully integrated into code and infrastructure that you can call from anywhere.

Introducing Agenter

Agenter makes coding agents embeddable. Here’s the entire API:

from agenter import AutonomousCodingAgent, CodingRequest

agent = AutonomousCodingAgent()

result = await agent.execute(CodingRequest(
    prompt="Add input validation to the user registration endpoint",
    cwd="/path/to/project"
))

# result.files contains all the code the agent wrote
for path, content in result.files.items():
    print(f"Modified: {path}")

That’s it. Give it a task, point it at a codebase, and see the changes. Simple enough to embed anywhere – a web service, a GitHub Action, or a Slack bot.

“But Wait: Don’t They Have SDKs Now?”

Yes, they do. Claude Code has an SDK. Codex has a CLI. OpenHands has their own interface. Each is powerful, but also disparate. In practice, your productivity is eroded due to different APIs, different patterns for tool execution, different approaches to streaming, error handling, and result formats, and other quirks. If you’re building an application that needs coding agent capabilities and you want flexibility across backends, the absence of a unified interface hits you with an N×M problem:

N applications × M backends = N×M integrations to build and worry about.

Agenter solves that through a single uniform interface for all coding agent backends:

N applications × 1 interface = N integrations

# Same code, different backends - just change one parameter
agent = AutonomousCodingAgent(backend="claude-code")  # or "codex", "openhands"

With Agenter, you simply switch from Claude Code to Codex with one string. Your application code stays identical.

Consistent Governance Everywhere

Beyond abstraction, Agenter provides a governance layer that works the same regardless of which coding agent backend you use. Specify your rules, limits, and caps once, and they will be enforced uniformly across all backends.

Budget controls. Set hard limits on cost or iterations. The agent stops when it hits any limit.

from agenter import Budget

result = await agent.execute(CodingRequest(
    prompt="Refactor the auth module",
    cwd="/path/to/project",
    budget=Budget(
	    max_cost_usd=0.50,
	    max_iterations=10
	  )
))

Validation loops. Generated code is checked for syntax errors before returning. Agenter retries with feedback if something’s is not working.

Path security. Restrict which files a coding agent can access and prevent directory traversal. These restrictions apply consistently across all backends.

Framework Integration

Building with PydanticAI? Agenter fits right in:

from agenter.adapters.pydantic_ai import CodingAgent

agent = CodingAgent(cwd="./workspace", backend="claude-code")
result = await agent.run("Add comprehensive error handling to the API routes")

Agenter is type-compatible with existing PydanticAI workflows. Use it as a pure drop-in or as a tool within a larger agentic system.

Open Source

As a library designed to prevent backend lock-in in the first place, Agenter is fully open source under Apache 2.0. No proprietary lock-in.

Getting Started

pip install agenter

Set your API keys, pick a backend, and start embedding coding agents in your applications. The documentation covers simple setup steps for each supported backend.

Install Agenter and start treating coding agents like any other service in your applications!

Agenter is built by Moonsong Labs, Inc.