Ideas

Agents don't just need more context. They need memory that survives the prompt. I want to explore what useful memory actually looks like in agentic systems, why most implementations are glorified note-taking, and how to build something that helps an agent get meaningfully better over time.

In a field that reinvents itself every six months, Prompty v2 does something almost suspiciously sane: it keeps the prompt format and upgrades the runtime. The result is a two-year-old .prompty file format that now speaks tools, tracing, structured output, streaming, and Python, TypeScript, C#, and Rust.

Everyone talks about "agents," but the core pattern is much simpler than the hype: observe, reason, act, and repeat. This idea breaks down the agentic loop into its essential parts, why it matters, and where most implementations go wrong.

We keep asking prompts to do the job of an operating system. This idea is about the real control surfaces in agentic software - schemas, tool permissions, approvals, workflow boundaries, and runtime policies - and why the best guardrails usually live outside the model.

The core training objective behind LLMs sounds almost embarrassingly simple. So why does it produce systems that can reason, translate, code, and chat? I want to build the intuition from the ground up without turning it into a graduate seminar.

Beneath all the hype, every large language model runs the same tiny trick over and over: predict the next token. I want to unpack that loop visually and intuitively so the whole machine suddenly makes sense.

If you understand basic neural nets but still feel like transformers are magic, this is the bridge. I want to connect the math from perceptrons, hidden layers, and representation learning to the ideas that make LLMs work.

Everyone says context matters, but that word is doing a lot of work. I want to unpack what context really is in an LLM: tokens, history, instructions, retrieved docs, and the invisible constraints that make models seem brilliant one minute and confused the next.

Quipy includes an AI builder that can either propose a plan or directly modify the app through specialized tools. That split is fascinating because it gets at a deeper product question: when should AI advise, and when should it act? There is a great post here about permission design, trust, and real-time feedback loops.

If you cannot see what your agent is doing, you are basically operating a haunted house with API keys. Quipy traces requests across frontend, backend, tools, and model calls with sanitization and propagation built in. That would make a great observability post for anyone building serious AI systems.

A lot of agent systems call it flexibility when what they really mean is chaos. Quipy models apps as directed graphs of tasks and transitions, then gives the agent only the valid next moves at runtime. I love this as a post about why constraints often make AI systems feel smarter, safer, and faster.

Quipy provisions Azure resources with Bicep and leans hard on managed identity and RBAC instead of scattering secrets through config files like confetti. That gives a very practical angle for writing about secure cloud architecture that is both cleaner and less miserable to maintain.

Nothing kills a voice interaction faster than a long, awkward pause while the system thinks. Quipy uses an async memory design with short-term compaction and long-term storage in Cosmos DB so recall and persistence do not interrupt the flow of conversation. This could be a fun piece on memory architectures for real-time AI.

Realtime voice demos look effortless right up until you build one and discover audio formats, interruptions, websockets, and latency are all trying to ruin your weekend. Quipy is a great case study in how to make browser-to-model voice interaction feel genuinely conversational instead of vaguely cursed.

Debugging voice systems is brutal if all you have is a transcript and a prayer. Quipy records audio, tool calls, workflow transitions, and generated outputs, then replays them on a synchronized timeline. That is the kind of feature that deserves a post all by itself.

Tool calling is easy to sketch and surprisingly hard to make reliable once users are speaking naturally. Quipy's runtime merges bindings, resolves missing parameters, validates structured input, and keeps the conversation moving while tools run. That makes it a strong post about the hidden systems that separate toy agents from useful ones.

Human speech is wonderful for communication and terrible for being valid JSON. Quipy uses structured generation as a side-channel to turn spoken answers into schema-valid tool arguments. That tiny detail is actually a huge unlock for reliable voice agents.

Most conversations about AI agents focus on the model, but that’s rarely where the real behavior comes from. This post explores how agency emerges from the combination of model capability, tool access, memory, and the runtime that orchestrates decisions and execution.