The end of platform block and the beginning of a new layer
LangGraph and CrewAI kept on blocking me from development when I needed a lightweight agent execution. The alternative was to use Codex to pump out a framework that met my needs.
My requirements were:
- Create lightweight agents using a markdown format like AGENTS.md or Visual Studio Code agent.md files.
- Control the context and execution environment without being forced into developing in a specific manner.
- Specify when I want to use a local LLM and when to use a provider like OpenAI.
- Be able to use structured output formats.
Codex
I'd say Codex did a not so bad job of taking my specifications and developing something that fits my needs. I'm sure it borrowed code or the structure from someone else's project buried deep in GitHub. For now, Codex and other code gen tools need a bit more arm twisting to give better module recommendations.
Giving it a spin
My first test run has been a basic documentation validator and an agent to validate it. I'm favouring this style as, with the addition of a tool I should be able to hookup with MLflow or another logging tool fairly easily.
The second use was integrating it into the scoring process for the Recruiter agent I've been developing.
The future
I believe that "coding" will transition into many different language styles. Some of them will be in markdown format with their own specifications. Others will likely have a more complex or simpler structure to them. There will be coding platforms which will use some internal format for encoding logic in the same way you see SaaS website builders. This direction will abstract the "code" layer away in the same way that libraries abstract the OS layer, compilers abstract bytecode, and the OS abstracts the hardware away. What these languages will end up as will likely be the same as we already have seen. We have everything from C, C++ to Python. There are already many documentation standards, and it won't be any surprise to see variations which allow a closer loop to go from description to production.
Slow phase out of code
I'm not super optimistic about the future of platforms which rely heavily on a specific language to code an agent in, manually creating functions or nodes. They have their place, but I'm not seeing that being where the bulk of the development will be. Languages like Python, Node, TypeScript, JavaScript will exist in those documents inline in the same way you may inline bytecode in C or C++ to access specific hardware features. As time goes on, I expect the inlining of code will reduce to very little, and the most specialized projects will continue to need specific coding instructions in many cases.
Introduction of the optimization layer
When code is translated into bytecode, there is also many ways that it is optimized and converted to various CPU architectures. There will be a place for more specialized frameworks and platforms for this as well. For example, SGLang gives you access to GPU optimization features which allow you to keep more computing on the GPU and prevent a slow round trip to the CPU. Tools are being made to detect when a text operation needs to be cached on CPU or not.
There is already companies working on optimization at the specification layer for many years and this is accelerating. At the coding level you have an extensive network of typings and tools for type checking for code. Similar tools will mature in this space, whatever you want to call it: Text to Code, Declarative Programming, Prompt-Based Software Generation, Vibe coding?