u/InevitableRecover782

I’m a college student who is trying to learn AI agents on my own.

Recently, I’ve been reading some open-source agent frameworks and agent projects, and I’m trying to build my own coding agent while experimenting with a few small tools that might improve how agents work.

Since I’m still early in this field, I’m curious how more experienced people usually learn agent development.

What do you think are the most important skills for building useful agents? Are there any directions worth focusing on? For example, should I spend more time on LLM APIs, tool calling, RAG, memory, evaluation, agent frameworks, backend engineering, or something else?

I’d really appreciate any advice from people who have actually built agents or worked on related projects.>!&#x200B;!<

Hi everyone,

I built an open-source tool called Thread Contract:

Thread Contract is a local MCP tool for Codex / Claude Code-style coding agents. It saves temporary instructions from the current conversation as editable thread-level rules, then re-injects the active rules into later turns through supported hooks.

The problem I am trying to solve is simple: during long-running coding-agent tasks, temporary instructions are easy to lose.

For example:

• do not commit during this task
• read PLAN before making changes
• explain which files were modified after each change

These rules are common, but they do not fit cleanly into existing rule or memory systems.

AGENTS.md / CLAUDE.md are good for long-term project rules and fixed development conventions, but not ideal for temporary task requirements. Frequent edits can also pollute the repository.

Long-term memory is good for user preferences and cross-conversation information, but not for short-term constraints that only matter in the current task.

Skills or prompt templates are good for reusable capabilities and fixed workflows, but they usually require manual triggering and are not ideal for stable per-turn rule injection.

Thread Contract is meant to sit between these layers: a thread-level runtime rule contract for the current agent task.

Current features:

• local SQLite storage
• MCP tools for rule management
• local Web UI to add, edit, enable, disable, or delete rules
• Codex-style hook support
• Claude Code-style adapter
• Python SDK for custom local agents

The goal is not to guarantee model compliance. It keeps active task rules explicit, visible, editable, and repeatedly present in the current thread context.

I am still early in the project and would appreciate feedback from people building or using coding agents:

• Does this solve a real problem in your workflow?
• Is thread-level scope the right abstraction?
• Should this be closer to memory, policy, or workflow management?
• Which agent environments would be worth supporting next?
• Is the installation flow too heavy?

Any criticism is welcome.