Problem is not having to remember to run agents in exact sequence and not having to repeat the processes.

That’s why I’ve created ctx traits and using them everyday, biggest wins for me are: sync across repos using git-based dependency manager and validator, which ensures version of the process / knowledge I’m using has been approved by me and hasn’t moved without my approval (similar to dependency managers lockfile approach).

This has allowed me to use same traits (it’s extension of skills with typed schemas and procedures, you can use skills with it as well as usual) across different repos without any copy pasting etc.

There are additional cool things like type-driven procedures with specific harness/agent associations and many more cool things coming soon.

The harness provides the model with its tools, context, and environment for execution.

However, I prefer not to have the model within that harness also bear the responsibility for remembering the process steps—like plan, implement, review, fix, and verify—deciding when to move from one to the next, and keeping track of the loop's state.

For tasks that need to be repeated, I’ve been moving that part into a reliable, deterministic runtime. Inside it, Claude, Codex etc simply take on interchangeable roles.

This setup makes changing models much simpler: the overall process remains consistent, and each role can be optimized independently.

I’ve been developing this approach as ctx.traits, if you're interested, here are the docs: https://ctx.company/traits/docs/quickstart/example/

https://ctx.company/blog/introducing-ctx-traits/

https://ctx.company/traits/docs/

Comments URL: https://news.ycombinator.com/item?id=49121545

Points: 1

# Comments: 0

For months, I have been searching for an approach to agents that does not feel like negotiating with the model. Each pattern I tried arrived with a long list of requirements and an implicit expectation that I would overlook its shortcomings, and left me managing output at several layers, always with a sense that I was compensating for something the system should have handled itself.

I eventually settled on ctx.traits: agent behaviors and workflows expressed as typed modules. Rather than writing in prose Markdown, you author in TypeScript. This produces a specification file, which becomes the artifact that is reviewed, locked, and diffed. The runtime executes the procedure one frame at a time: at each step, only the declared inputs are provided, nothing more. Submitted output is validated against the step's schema before it is accepted. The loop exits on a typed verdict field, not when the model arbitrarily decides it is finished.

If you have thoughts, questions, or experiences with similar patterns, I would appreciate hearing them. I am still refining this approach, and outside perspectives are valuable.

Comments URL: https://news.ycombinator.com/item?id=49111620

Points: 2

# Comments: 1

Comments URL: https://news.ycombinator.com/item?id=49097463

Points: 2

# Comments: 0

I don’t understand why companies still place AI in their system at authority-forming level, if anything it should sit at least behind single guard / validator that is explicitly coded and tested, never in front of presentation layer.

AI is great for learning, but you know what’s most important thing for children as part of their learning? Presence of a parent.

Why not make this an assistant for parent & child learning session, where you can use it as encyclopedia lookup or permutation / generation of an exercise or even cheatsheet / checklist for your learning session?

I think there’s huge value in being able to have such thing, where you don’t have to pull out your phone when doing something with your child and instead you could ask that assistant for a lookup online, but putting child in front of a screen and putting it’s self-development in a hands of AI is just irresponsible, lazy and quite frankly dangerous