# AgentField

> Machine-readable docs index for the AgentField control plane, CodeAF, and SDKs.

Contract-Version: 2026-03-24-v1
Docs-Revision: 8cbd2ece0a88

AgentField provides production primitives for agent systems: Agents, Reasoners, Skills, Harness integrations, cross-agent calls, discovery, memory, DID authentication, verifiable credentials, and workflow tracing. CodeAF is an open-source software factory with built-in specialists: /senior-dev for coding, /sec for security audits and /review for GitHub pull requests.

## Section indexes

- [Documentation](https://agentfield.ai/docs/llms.txt): AgentField and CodeAF documentation pages
- [CodeAF](https://agentfield.ai/codeaf/llms.txt): CodeAF product page and documentation
- [Blog](https://agentfield.ai/blog/llms.txt): AgentField blog posts

## When to Use AgentField

AgentField is the backend layer around agents that already work: it makes them
callable, governable, and observable in production. Reach for it when the job is
operational, not when the job is authoring prompt logic.

Use AgentField when you need to:

- Expose an agent as an HTTP endpoint other services can call, retry, and depend on
- Run one agent from another across services, with routing and tracing handled for you
- Run work that outlives a request (minutes to days) with durable queueing, webhooks on completion, and resumable state
- Fan out hundreds or thousands of parallel agent calls from a single request and get one cost and latency accounting back
- Put a human approval gate in the middle of an autonomous run and resume exactly where it paused
- Share state between agents with explicit scopes (workflow, session, actor, global), including handlers that fire when a key changes
- Discover capabilities at runtime instead of hardcoding a tool list, so a newly deployed agent is callable without a redeploy
- Orchestrate coding harnesses (AForge, Claude Code, Codex, Gemini CLI, OpenCode) as budget-capped, tool-restricted workers
- Attach cryptographic identity (DIDs), verifiable credentials, and policy enforcement to agent-to-agent calls
- Answer "why did the agent do that?" from a tamper-evident execution record rather than from logs
- Run all of the above on your own infrastructure. AgentField is Apache-2.0 and self-hosted, including fully local mode on a laptop

Do not reach for AgentField when:

- You want a prompt-authoring or chain-authoring library. Keep using the framework you like and put AgentField underneath it.
- You want a visual, no-code workflow builder. AgentField is programmatic and developer-first.
- You are making a single stateless LLM call from one service. Call the model provider directly.

How to call it:

- Python: `pip install agentfield`, then decorate functions with `@app.reasoner` or `@app.skill`
- TypeScript: `npm install @agentfield/sdk`
- Go: `go get github.com/Agent-Field/agentfield/sdk/go`
- CLI: `curl -sSf https://agentfield.ai/get | bash` installs the `af` binary (`af init`, `af dev`, `af server`, `af mcp`, `af share`)
- MCP: an agent can register Model Context Protocol servers with `af add --mcp`, or set `enable_mcp=True` on a Python agent, and their tools become callable skills

## Cost

AgentField is free. One tier, $0, everything included.

- Price: **$0 USD**. There is no paid tier, no premium edition, and no enterprise SKU.
- Seats: unlimited. No per-user, per-developer, or per-agent charge.
- Usage: unmetered. AgentField imposes no cap on executions, agents, workflows, or memory.
- No credit card, no account, and no signup. Clone it and run it.
- No trial period, so nothing expires or degrades.
- Licence: Apache-2.0, which also means no vendor lock-in and no licence audit.

Every capability ships in the open-source build, including the governance features
other vendors put behind an enterprise tier: cryptographic identity, policy
enforcement, approval gates, verifiable credentials, and tamper-evident audit trails.

The only money involved is what you already pay your own providers: the compute you
run AgentField on, and your LLM provider's tokens. Both are billed directly by those
providers. AgentField is self-hosted, so nothing is resold or marked up.

Full breakdown: https://agentfield.ai/pricing.md

## How Agents Should Query This Site

Every endpoint below is public, unauthenticated, and read-only. Errors are RFC 9457
problem documents (`application/problem+json`) with a machine-readable `code` and a
`resolution`. Cacheable 200s omit `RateLimit-*`. 429 and other no-store errors
still carry them. Pace against those.

- Search the docs: `GET https://agentfield.ai/api/v1/search?q=<query>&limit=5`
- List every page: `GET https://agentfield.ai/api/v1/topics`
- Read one page as markdown: `GET https://agentfield.ai/api/v1/page?path=/docs/<slug>`
- Full API description: `GET https://agentfield.ai/openapi.json`
- Agent instructions: `GET https://agentfield.ai/agents.md`

Any page also serves markdown through content negotiation:
`curl -H "Accept: text/markdown" https://agentfield.ai/docs/agentfield/learn/quickstart`

## Core Concepts

- Agents: Production microservice containers for registered functions and control-plane integration
- Skills: Deterministic functions for repeatable work
- Reasoners: LLM-backed functions with schema-aware inputs and outputs
- Harness: Runs a coding agent through app.harness(). Defaults to AForge, AgentField's native harness that ships with the af binary; Claude Code, Codex, Gemini CLI, and OpenCode are opt-in overrides via the provider field

## Key Differentiators

- Cross-agent calls through the control plane
- Discovery by agent, capability, tags, and health
- Shared memory with workflow, session, actor, and global scopes
- Async execution, webhooks, and human-in-the-loop approvals
- DID authentication and verifiable credentials for governed execution
- Python, TypeScript, and Go SDKs

## Quick Start

```
pip install agentfield          # Python
npm install @agentfield/sdk     # TypeScript
go get github.com/Agent-Field/agentfield/sdk/go  # Go
```

## Machine Endpoints

- Agent instructions (when to use, how to call): https://agentfield.ai/agents.md
- Pricing (free, $0, no paid tier): https://agentfield.ai/pricing.md
- OpenAPI 3.1 description of this site's API: https://agentfield.ai/openapi.json
- Docs search API: https://agentfield.ai/api/v1/search?q=<query>&limit=5
- Docs index API: https://agentfield.ai/api/v1/topics
- Single page API: https://agentfield.ai/api/v1/page?path=/docs/<slug>
- Docs manifest (JSON): https://agentfield.ai/docs-ai.json
- Full docs corpus: https://agentfield.ai/llms-full.txt
- Per-page markdown: https://agentfield.ai/llm/docs/<slug>
- Markdown via content negotiation: any page with `Accept: text/markdown`
- Plugin/discovery manifest: https://agentfield.ai/.well-known/ai-plugin.json

## AgentField Documentation Pages

- Quickstart: https://agentfield.ai/docs/agentfield/learn/quickstart
- Features: https://agentfield.ai/docs/agentfield/learn/features
- Python SDK: https://agentfield.ai/docs/agentfield/reference/sdks/python
- TypeScript SDK: https://agentfield.ai/docs/agentfield/reference/sdks/typescript
- Go SDK: https://agentfield.ai/docs/agentfield/reference/sdks/go
- REST API: https://agentfield.ai/docs/agentfield/reference/sdks/rest-api
- AgentField CLI (af) Reference: https://agentfield.ai/docs/agentfield/reference/sdks/cli
- AgentField MCP server integration (af mcp, enable_mcp): https://agentfield.ai/docs/agentfield/integrations/mcp
- Agent discovery (MCP-style capability registry): https://agentfield.ai/docs/agentfield/quick-guides/agent-discovery
- Webhooks and event triggers: https://agentfield.ai/docs/agentfield/quick-guides/webhook-triggers
- Deployment: https://agentfield.ai/docs/agentfield/reference/deploy
- Testing: https://agentfield.ai/docs/agentfield/reference/testing
- Troubleshooting: https://agentfield.ai/docs/agentfield/reference/troubleshooting

## CodeAF Documentation Pages

- [Build, audit and review with CodeAF](https://agentfield.ai/docs/codeaf): Built-in specialists: /senior-dev for coding, /sec for security audits and /review for GitHub pull requests.
- [Ask from home](https://agentfield.ai/docs/codeaf/ask): Ask here answers a question from home without adding a conversation to your list.
- [Attach your Codex plan](https://agentfield.ai/docs/codeaf/attach-a-subscription): Your Codex plan becomes one more model service, signed in once in your browser.
- [Attach files and pictures](https://agentfield.ai/docs/codeaf/attach-files): Put a file next to your message and the agent reads it with the words.
- [Budgets at every level](https://agentfield.ai/docs/codeaf/budgets): Walk away from a fleet of agents knowing what each part of it can spend.
- [Chain of command](https://agentfield.ai/docs/codeaf/chain-of-command): Questions climb the chart. Only what no manager can decide reaches you.
- [Let two chats talk to each other](https://agentfield.ai/docs/codeaf/chats-talk-to-each-other): Bring one conversation's state into another with an @ mention, or let teammates message each other by handle.
- [Choose the model for a task](https://agentfield.ai/docs/codeaf/choose-the-model): Name a model in plain words and that one task runs on it; pin a seat for every task; or say nothing and let the crew be picked for you.
- [Commands and keys](https://agentfield.ai/docs/codeaf/commands): Every key, slash command and terminal command in CodeAF, grouped by the screen you are on.
- [Connect your services](https://agentfield.ai/docs/codeaf/connections): Connect a service once, and the agent can read it and act in it.
- [Create a manager](https://agentfield.ai/docs/codeaf/create-a-manager): Choose an existing team member as its manager, or create a fresh manager, then open its conversation to send work.
- [Ephemeral workers](https://agentfield.ai/docs/codeaf/ephemeral-workers): Workers spend only for the length of a job.
- [FAQ](https://agentfield.ai/docs/codeaf/faq): What developers ask before and after they try CodeAF, from other agents to keys, cost, teams, specialists and safety.
- [Fire and steer](https://agentfield.ai/docs/codeaf/fire-and-steer): Hand work off in one line and keep talking while it runs in parallel.
- [Your first team in 5 minutes](https://agentfield.ai/docs/codeaf/first-team): Five minutes from one chat to a team of agents run by a manager.
- [Hand a job to a specialist](https://agentfield.ai/docs/codeaf/hand-a-job-to-a-specialist): Choose senior-dev for a coding change, sec for a local security audit, or review for a GitHub pull request.
- [Headless mode](https://agentfield.ai/docs/codeaf/headless): Headless mode runs one job with nobody watching, then exits with an answer and an exit code.
- [Keeps working when you close it](https://agentfield.ai/docs/codeaf/keeps-working): Closing the window ends the view, not the work.
- [Put a manager over other managers](https://agentfield.ai/docs/codeaf/manager-of-managers): Split a team under a second manager with one sentence, or put one manager over every team you run.
- [Managers](https://agentfield.ai/docs/codeaf/managers): You stop being the router between agents.
- [Pictures, video, voice and music](https://agentfield.ai/docs/codeaf/media): Ask for a picture, a clip, a voiceover or a jingle in plain words, and get the file.
- [The Model Pool](https://agentfield.ai/docs/codeaf/model-pool): Installs measure models on real work; the Model Pool shares the numbers, never the code.
- [Pareto crewing](https://agentfield.ai/docs/codeaf/pareto-crewing): Pick a model for each seat, per task, on the cost-quality frontier.
- [Playbooks](https://agentfield.ai/docs/codeaf/playbooks): Setups to copy today, grouped by what you get: an org of agents, safer merges, work that runs while you sleep, work that goes wide, and work beyond code.
- [Run a hundred jobs at once](https://agentfield.ai/docs/codeaf/playbooks/a-hundred-at-once): One brief becomes a hundred parts, one per file, and all hundred run side by side under a cap you set.
- [Bring your skills](https://agentfield.ai/docs/codeaf/playbooks/bring-your-skills): Skill folders you already wrote for other tools shape CodeAF's work in place, team members included.
- [Build a software company](https://agentfield.ai/docs/codeaf/playbooks/build-a-software-company): Write one message to a global manager and a company of teams plans, builds and tests a feature.
- [Claude Code plans, CodeAF builds](https://agentfield.ai/docs/codeaf/playbooks/claude-code-architect): Claude Code plans and reviews, and CodeAF's crew writes the implementation.
- [Give new hires a codebase tour with audio](https://agentfield.ai/docs/codeaf/playbooks/codebase-tour): One task writes a tour page per module with a checked gotcha, and one more message turns every page into a spoken walkthrough.
- [Connect teams](https://agentfield.ai/docs/codeaf/playbooks/connect-teams): One team's result wakes the next team with no message from you, and you hear once at the end.
- [Start at your desk, finish on your phone](https://agentfield.ai/docs/codeaf/playbooks/desk-to-phone): Start a task on the big screen, close it, and pick up the same conversation from a phone-width terminal.
- [Keep the docs in step with the code](https://agentfield.ai/docs/codeaf/playbooks/docs-follow-code): A file watch notices every code change and updates the API docs to match, so the docs never fall behind.
- [Fix the build before you push](https://agentfield.ai/docs/codeaf/playbooks/fix-before-push): A git pre-push hook runs the tests, and when they fail, codeaf do fixes the code and the next push carries the fix.
- [Keep main green](https://agentfield.ai/docs/codeaf/playbooks/keep-main-green): A watch runs the tests on a schedule, and when they go red, a worker fixes the code and tells you in one line.
- [Make a launch campaign from one brief](https://agentfield.ai/docs/codeaf/playbooks/launch-campaign): A small team turns a product brief into copy, a banner, a social picture and a voiceover in a few minutes.
- [Make the big calls yourself](https://agentfield.ai/docs/codeaf/playbooks/make-the-big-calls): Name the decisions that are yours, and they climb to you as one question while the rest of the work runs on.
- [Migrate every package at once](https://agentfield.ai/docs/codeaf/playbooks/migrate-every-package): One brief moves a whole codebase off a deprecated API, one worker per package, all at the same time.
- [Run a nightly test routine](https://agentfield.ai/docs/codeaf/playbooks/nightly-routine): Every night the suite runs, failures become issues, easy bugs get fixed, and a report waits for you in the morning.
- [Run an on-call pager](https://agentfield.ai/docs/codeaf/playbooks/on-call-pager): A watch checks your service every few minutes, and when it fails, a worker finds the cause, fixes it and logs the incident.
- [Organize a messy window](https://agentfield.ai/docs/codeaf/playbooks/organize-a-messy-window): Eleven unrelated chats become three named teams with managers, and one manager reports on all of them.
- [Cut a release trailer from the changelog](https://agentfield.ai/docs/codeaf/playbooks/release-trailer): One brief turns git log into release notes, a voiceover, music, a title card and a clip, cut into one trailer.
- [Settle a question with a research pod](https://agentfield.ai/docs/codeaf/playbooks/research-pod): Three members each build and measure one answer at the same time, and the manager writes the decision with a table.
- [Review every change](https://agentfield.ai/docs/codeaf/playbooks/review-every-change): Every change is built on its own branch, checked by a reviewer, and merged only on a pass.
- [Gate every merge with a review panel](https://agentfield.ai/docs/codeaf/playbooks/review-panel): A developer builds each change on a branch, three reviewers check it for security, tests and API shape at once, and only three passes merge.
- [Ship a feature while you are away](https://agentfield.ai/docs/codeaf/playbooks/ship-while-away): Send one brief, close the terminal, and come back to a checked branch in the same conversation.
- [Close twenty issues at once](https://agentfield.ai/docs/codeaf/playbooks/twenty-issues-at-once): Hand one brief that names twenty issues, and twenty workers take one each, side by side.
- [Remote machines](https://agentfield.ai/docs/codeaf/remote-machines): Your screen is only a view; the work lives on the machine that owns it.
- [review: GitHub pull requests](https://agentfield.ai/docs/codeaf/review): Review a GitHub pull request with /review: focused reviewers, challenged findings and a saved report. Posting is a separate explicit action.
- [Rules](https://agentfield.ai/docs/codeaf/rules): Write your house rules once. Applicable rules reach conversations and task workers as conditions on their work.
- [Running unattended](https://agentfield.ai/docs/codeaf/running-unattended): Work that runs while you sleep is held to what you already said yes to.
- [Schedules](https://agentfield.ai/docs/codeaf/schedules): Say when, and the work happens then, every time.
- [sec: security audits](https://agentfield.ai/docs/codeaf/sec): Audit local code with /sec: repository or changes, evidence and suggested fixes, with Markdown, JSON and SARIF reports.
- [senior-dev](https://agentfield.ai/docs/codeaf/senior-dev): Hand senior-dev a whole coding change and it carries it through alone, from the brief to a checked result on a branch you can merge.
- [Specialists](https://agentfield.ai/docs/codeaf/specialists): Build with /senior-dev, audit code with /sec and review GitHub pull requests with /review. Purpose-built specialists, built into CodeAF.
- [Standing orders](https://agentfield.ai/docs/codeaf/standing-orders): Some of what you say is for right now. Some of it is meant for always.
- [Steer work while it runs](https://agentfield.ai/docs/codeaf/steer-work-while-it-runs): Add a note to a running task, stop it when it goes wrong, and run it again on a stronger crew, without starting over by hand.
- [Teams](https://agentfield.ai/docs/codeaf/teams): Many agents become a few outcomes you can name and steer.
- [Troubleshooting](https://agentfield.ai/docs/codeaf/troubleshooting): What you see, why it happens, and the exact key or command that fixes it.
- [The Wall](https://agentfield.ai/docs/codeaf/wall): When many chats work at the same time, the wall shows every one of them, live.
- [Watches](https://agentfield.ai/docs/codeaf/watches): A watch waits for the world to change, and acts only when it does.
- [Your org chart](https://agentfield.ai/docs/codeaf/your-org-chart): Your org chart grows as deep as the work: managers hire managers.

## Open Source Ecosystem

AgentField has open-source example projects and companion repositories in the AgentField GitHub organization.

Browse the organization: https://github.com/agent-field

## Blog

- [How we ran a 250-agent security audit for 90 cents](https://agentfield.ai/blog/250-agents-90-cents): A full security audit that runs 166 to 255 agent calls and confirms 28 exploitable findings costs between 18 and 90 cents, because each call is small, routed to the right model, and capped.
- [Add an agent mesh to your existing FastAPI or Next.js app](https://agentfield.ai/blog/add-agents-to-your-existing-app): Deploy a reasoning agent as a sidecar service and call it over REST from the app you already have. No framework adoption, no rewrite.
- [Agents that debug agents](https://agentfield.ai/blog/agents-that-debug-agents): A workflow fails at 2am. Instead of a human paging through logs, an operator agent fetches the failed DAG, diagnoses the root cause, and drafts a fix behind an approval gate while you sleep.
- [The agent that finds its own tools](https://agentfield.ai/blog/agents-that-find-their-own-tools): A reasoner that calls app.ai(tools="discover") sees every capability registered on the mesh at call time and invokes what it needs, so deploying a new agent tonight makes it callable by tomorrow with zero redeploys.
- [Agents that run for three days](https://agentfield.ai/blog/agents-that-run-for-days): Fire an agent with one POST, close the connection, and get a signed webhook when it finishes hours or days later, backed by a durable PostgreSQL queue with retries.
- [An agent that ships new versions of itself](https://agentfield.ai/blog/agents-that-ship-themselves): A self-improvement loop where a production agent records its own failures to memory, an improver agent reads them and writes a revised prompt, and that prompt ships as a new version the self-tuning rollout then canaries behind a human gate.
- [Approve your agents from your phone](https://agentfield.ai/blog/approve-from-your-phone): Notify yourself when an agent pauses, then approve or reject it with one tap from a lock screen. A five-line notify plus a twenty-line signed handler turns any pause into a phone gate.
- [Build your own personal assistant](https://agentfield.ai/blog/build-your-own-personal-assistant): A reasoner with per-chat memory that reaches your other agents, plus a 70-line Telegram bridge you own. Text your personal stack from your phone.
- [Claude Code as a function](https://agentfield.ai/blog/claude-code-as-a-function): Call a multi-turn coding agent like Claude Code from your backend with a dollar budget cap, a turn limit, restricted tools, and typed output.
- [A fleet of coding agents with budget caps](https://agentfield.ai/blog/coding-agent-fleet): Run N coding agents in parallel as one governed fleet. Each gets its own checkout, a dollar cap, a turn limit, and a tool allowlist, and you get back one cost table.
- [Fan out 1,000 parallel agents from one request](https://agentfield.ai/blog/fan-out-1000-agents): A recursive reasoner that decomposes a question and calls itself in parallel through the control plane, depth-capped, with queueing and tracing handled for you.
- [Human approval gates in 20 lines](https://agentfield.ai/blog/human-approval-20-lines): Suspend a running agent on a low-confidence decision, notify a reviewer, and resume exactly where it stopped. The wait state lives in the control plane, so it survives restarts.
- [From LangGraph prototype to production](https://agentfield.ai/blog/langgraph-to-production): The mechanical path from a LangGraph StateGraph that works in a notebook to reasoners other services can call, retry, and run for 40 minutes.
- [A nightly maintenance fleet for your repos](https://agentfield.ai/blog/nightly-repo-fleet): One scheduled reasoner that clones your repos at 3am, runs a budget-capped coding agent on each, and leaves a morning summary and a stack of ready PRs behind an approval gate.
- [One control plane for XGBoost and agents](https://agentfield.ai/blog/one-control-plane-for-ml-and-agents): Wrap a trained XGBoost model as a skill, serve 95% of traffic in milliseconds, and cascade the low-confidence remainder to a reasoner. Same tracing, same DAG, one ops story.
- [Pipelines that build themselves](https://agentfield.ai/blog/pipelines-that-build-themselves): An intake reasoner reads the input, decides which analysis dimensions it actually needs, then the orchestrator spawns exactly those specialists with prompts written at runtime, so the pipeline shape is a trace of what happened rather than a graph declared upfront.
- [Agents that wake up when data changes](https://agentfield.ai/blog/reactive-agents): Declare @app.memory.on_change("order_*") and a handler fires whenever a matching key changes, written by any agent, in any scope. No cron, no broker, no consumer groups.
- [The deployment that promotes itself](https://agentfield.ai/blog/self-tuning-rollouts): A self-tuning rollout deploys a new agent version at a small traffic weight, then an operator agent polls per-version failure rates and shifts weight itself, promoting on wins and rolling back on regressions.
- [Simulate a market with 200 agents](https://agentfield.ai/blog/simulate-a-market-with-200-agents): A market simulation where 200 trader reasoners read a shared order book from global memory, decide with a cheap model, and post orders back every round, while an orchestrator fans them out and code clears the price, all watchable live in the dashboard DAG.
- [Thinking in reasoners](https://agentfield.ai/blog/thinking-in-reasoners): The capstone mental model for the personal stack. Five habits that turn a pile of prompts into a system, each shown as a small before and after, with the one table you need for deciding between app.ai and app.harness.
- [Your personal control plane](https://agentfield.ai/blog/your-personal-control-plane): Run AgentField in local mode on your own laptop or homelab, register one agent, and call it over HTTP. This is the substrate the rest of the personal stack builds on.
- [Capabilities You Do Not Own](https://agentfield.ai/blog/capabilities-you-do-not-own): Twenty years of integration have run on copying data across a boundary. Agentic consumers make that trade worse. Agentic Resource Discovery is the visible half of the response. The runtime layer that has to sit beneath it is the harder half, and data platforms are the most natural place to see it land.
- [How an AI-Native Engineering Team Does Code Review](https://agentfield.ai/blog/ai-native-code-review): When the writer and the reviewer are the same intelligence, the pull request gate stops doing what it was designed to do. We rebuilt code review at AgentField from the ground up — what changed, why, and what we open-sourced.
- [The Hidden Primitive Behind Claude Code, Codex, and Gemini](https://agentfield.ai/blog/harness-as-membrane): Part 2 of the harness orchestration series. Four properties of the boundary surface of a single harness: the workspace it reads at startup, the boundary that drifts while it runs, the verifiers it can and cannot see, and the blast radius the team can afford to undo.
- [An Engineer's Guide to Harness Orchestration](https://agentfield.ai/blog/harness-as-black-box): Why orchestration changes when the unit decides for itself. The harness is a fundamentally new kind of computational object, defined by agency, embodiment, and persistence in one primitive. Part 1: The Black Box.
- [What is harness orchestration?](https://agentfield.ai/blog/what-is-harness-orchestration): What changes when the atomic unit of intelligence is no longer an API call, or no longer a single LLM call. From invoking one model to orchestrating teams of autonomous harnesses like Claude Code, Cursor, Codex, Gemini, and the systems built above them.
- [Beyond Vibe Coding: How We Ship Production Code with 200 Autonomous Agents](https://agentfield.ai/blog/beyond-vibe-coding): What we learned orchestrating 200+ Claude Code instances on a shared codebase: two LLM primitives, three nested failure loops, and checkpoint-based execution.
- [What Breaks When AI Makes a Trillion Decisions](https://agentfield.ai/blog/what-breaks-trillion-decisions): The world makes hundreds of billions of API calls every day. Each call carries a decision. Most of these decisions are hardcoded into configuration files and compiled binaries. But that's starting to change, and the infrastructure isn't ready.
- [A Useful Way to Think About Where AI Fits in Software](https://agentfield.ai/blog/where-ai-fits-in-software): The speed at which agent-style systems have moved from research to daily use has been remarkable, even as their impact inside real business environments remains uneven. A clearer split begins to appear when you look at where intelligence sits in the architecture.
- [The AI Agent Accountability Gap](https://agentfield.ai/blog/ai-agent-accountability-gap): Why AI backends need tooling we haven't built yet. When a returns agent approved a $12,000 refund it shouldn't have, nothing looked wrong. The logs showed no errors, every validation check passed. The problem was that no one could explain why it made that call.
- [The Move from Monolithic AI to Modular Systems](https://agentfield.ai/blog/microservices-moment-for-ai): What a documentation chatbot taught us about building AI features that scale. When web applications hit complexity, we extracted microservices. The same evolution is happening with AI.
- [IAM for AI Backends](https://agentfield.ai/blog/iam-ai-backends): How DIDs and Verifiable Credentials enable trust for AI agents
- [The AI Backend](https://agentfield.ai/blog/ai-backend): Five years from now, every serious software company will have an AI backend - a reasoning layer that sits alongside their services, making decisions that used to be hardcoded.

## Links

- Documentation: https://agentfield.ai/docs
- CodeAF: https://agentfield.ai/codeaf
- Agent control plane: https://agentfield.ai/backend
- Enterprise: https://agentfield.ai/enterprise
- Integrations: https://agentfield.ai/integrations
- GitHub: https://github.com/agent-field/agentfield
- Blog: https://agentfield.ai/blog
- Discord: https://agentfield.ai/discord
- Agent instructions: https://agentfield.ai/agents.md
- Machine-readable manifest: https://agentfield.ai/docs-ai.json
- Full LLM context: https://agentfield.ai/llms-full.txt