Skip to content

Iterating & Extending

AgentInk is self‑evolving: it can read and modify its own codebase, add tools, fix bugs, and ship the changes. You drive this from Slack in plain language — you don't edit code yourself unless you want to.

Ask it to change itself

@agentink add a tool that posts a weekly RSS digest to this channel
@agentink the image tool times out on large prompts — investigate and fix it
@agentink make the meeting facilitator wait longer before interjecting by default

AgentInk will inspect the relevant files (it can read_file / search the repo), plan the change, implement it (write_file), run tests (execute_shell_command in its sandbox), and surface a PR for review.

The Order of Operations (enforced)

For any non‑trivial change, AgentInk follows — and will remind you of — this workflow:

  1. Propose & discuss the change in the channel.
  2. Branch from main (no direct commits to main).
  3. Implement & test locally (unit + smoke tests).
  4. Open a PR with a clear description and test results.
  5. Review & approve by an approved developer (e.g. Gregory or Rob).
  6. Merge to main — only by an approved person, after review.
  7. Deploy & verify with post‑deployment smoke tests.

Two ways it writes code

  • Inline — for changes to its own repo, it edits files and runs tests directly in its sandbox.
  • Claude Code one‑shot — for larger, ticket‑scoped work in any repo, it delegates to a sandboxed Claude Code session that branches, implements, and opens a PR (run_claude_code_one_shot_tool).

How a new capability becomes a tool

AgentInk's abilities are Python functions registered in a tool map and exposed to its reasoning model as function declarations. To add a capability, the pattern is:

  1. Write the function (e.g. def post_rss_digest(channel_id, feed_url) -> str:).
  2. Register it in the tool map and add a function declaration so the model can call it.
  3. Add a short instruction in the system prompt describing when to use it.
  4. Test, PR, review, deploy.

You can ask AgentInk to do all of this for you — describe the capability and it will scaffold it following this pattern.

The Consequence Gate (how it stays safe while evolving)

Binding, physical, transactional, or outbound actions are intercepted and held for a named human's approval before they execute — unlocking doors, rebooting gear, sending external messages, placing orders, etc. While iterating, this means AgentInk can propose and prepare consequential actions, but a human confirms before anything real happens. AgentInk reports such actions as pending and never claims they succeeded until it has a real result.

Watching it work

Every step of AgentInk's reasoning — the parent Slack agent, any child agents, and the Android agent — streams to the Control Center dashboard as [THOUGHT] / [ACTION] / [RESULT], with searchable history. This is the fastest way to see what it's actually doing while it iterates. See The Dashboard →.