Agentify – Declarative AI Agent Prototyping in YAML

TL;DR

TL;DR: Agentify is a lightweight Python toolkit that lets you define AI agents with YAML instead of code — pick a model provider, write a role prompt, and run from the CLI.

Source and Accuracy Notes

• Project page: backplane-cloud/agentify-toolkit
• Source repository: github.com/backplane-cloud/agentify-toolkit
• License: Apache 2.0
• HN launch thread: news.ycombinator.com/item?id=47013725 ← verified via HN Algolia

What Is Agentify?

Agentify is a lightweight, declarative-first toolkit for prototyping AI agents in Python. The README describes it as:

Build and experiment with AI agents using simple declarative specs.

Instead of writing Python classes or wiring up framework logic, you define agents as YAML files and interact with them via a CLI. The toolkit handles provider routing, model selection, and the agent loop — your job is writing the role prompt.

Supported providers (auto-detected from environment):

• OpenAI (GPT-4 series)
• Anthropic (Claude series)
• Google (Gemini series)
• AWS Bedrock
• Mistral AI
• DeepSeek
• XAI (Grok)
• Ollama (local models)

Note from the README: Agentify is not a workflow orchestrator or production framework. It is for agent building, experimentation, and prototyping only.

Setup Workflow

Step 1: Install

pip install agentify-toolkit
```bash

Verify the CLI is available:

```bash
agentify --help
```bash

### Step 2: Configure API Keys

Copy the example `.env` file:

```bash
cp .env.example .env
```bash

Populate it with your provider keys:

```bash
OPENAI_API_KEY=your-openai-key
ANTHROPIC_API_KEY=your-anthropic-key
DEEPSEEK_API_KEY=your-deepseek-key
MISTRAL_API_KEY=your-mistral-key
XAI_API_KEY=your-xai-key
GOOGLE_API_KEY=your-google-key
BEDROCK_API_KEY=your-bedrock-key
OLLAMA_API_KEY=your-ollama-key
```bash

Or use the CLI to add providers interactively:

```bash
agentify provider add anthropic
agentify provider list
```bash

All configured providers are automatically detected at runtime.

### Step 3: Create an Agent

**Option A — via CLI (interactive):**

```bash
agentify agent new
```bash

The CLI prompts for: `name`, `description`, `version`, `provider`, `model`, `api key`, and `role`. The role is the system prompt that defines the agent's persona.

**Option B — manually via YAML:**

```yaml
# agent.yaml
name: claude
description: AI Security Engineer
version: 0.1.0
model:
  provider: anthropic
  id: claude-sonnet-4-5
  api_key_env: ANTHROPIC_API_KEY
role: |
  You are an AI Security Engineer.
  Provide concise, practical answers with examples.
```bash

### Step 4: Run the Agent

```bash
agentify agent run agent.yaml
```bash

### Step 5: Serve or Deploy

```bash
agentify serve agent.yaml
agentify deploy agent.yaml
```bash

## Deeper Analysis

**What makes it different:** Most agent frameworks are library-first — you write Python code to define behavior. Agentify inverts this: you write YAML and the CLI drives everything. This makes it particularly fast for iteration on agent personas and model comparison.

**Architecture as text diagram:**

```text
agent.yaml (YAML spec)
       │
       ▼
  agentify CLI
       │
       ▼
Provider router (reads .env, auto-detects available keys)
       │
       ▼
Selected model (OpenAI / Anthropic / DeepSeek / etc.)
       │
       ▼
Agent loop (role prompt + tool use)
```bash

**Supported models per provider (from README):**

| Provider   | Example model              |
| ---------- | -------------------------- |
| OpenAI     | gpt-4                       |
| Anthropic  | claude-sonnet-4-5           |
| Google     | gemini series              |
| DeepSeek   | deepseek-chat              |
| Mistral AI | mistral series             |
| XAI        | grok series                |
| AWS Bedrock| bedrock models             |
| Ollama     | local models               |

**Limitations:** The README explicitly states this is not for production workloads. For pipelines, multi-step workflows, or persistent memory, you would outgrow Agentify quickly. It shines at the prototyping stage.

## Practical Evaluation Checklist

- pip install completes without errors
- `agentify --help` returns CLI help
- `agentify provider add` updates `.env`
- `agentify agent new` creates a valid `agent.yaml`
- `agentify agent run` produces a response from the configured model
- Multiple providers can coexist in `.env` without conflict

## Security Notes

- API keys stored in `.env` — never commit this file to version control
- No tool use or file system access by default — agents are sandboxed to the model prompt loop
- Read the [QUICKSTART](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/QUICKSTART.md) for the full list of supported CLI commands

## FAQ

**Q: Can I use local models?**
**A:** Yes. Set up Ollama locally and configure `OLLAMA_API_KEY` in `.env`. The provider router auto-detects it.

**Q: How is this different from LangChain or LlamaIndex?**
**A:** Those are library-first frameworks for building complex pipelines. Agentify is CLI-first and declarative — you write YAML, not Python code. It is purpose-built for rapid persona prototyping and model comparison.

**Q: Does it support tool use?**
**A:** The README focuses on agent definition via role prompts. For extended capabilities, check the [CLI reference](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/docs/CLI_REFERENCE.md) in the repo.

**Q: Is this production-ready?**
**A:** The README explicitly says no — it is for prototyping and experimentation. Use a proper orchestration framework for production workloads.

## Conclusion

Agentify fills a specific niche: you want to test a new agent persona or compare model responses without scaffolding a Python project. Write a YAML file, run one command, iterate on the role prompt. If you outgrow it, you have a clear signal that the agent concept is worth building out properly.

To get started:

```bash
pip install agentify-toolkit
agentify agent new