ODE Devlog 02

01-The not so humans...

Continued from ODE Devlog 01

You're Absolutely Right, I did fabricate that

We started with a simple MCP wrapper on our API and were pleasantly surprised by how intelligible and reliable the results were, but with agents reliability and intelligibility were just a part of it. There were a lot of decent data op oriented MCP or APIs for agentic use from competitors, but intelligence operations required serious token use: Efficiency, reducing hallucinations in data ops, and zero-shot operations became our objectives. So we redesigned for 0 system prompting and minimal token use.

When we were conducting customer surveys and doing user research the pain was there long before solutions started hitting the market. Almost everyone we spoke trying to get autonomous AI implementations had pains with costs, flexibility, consistency, and accuracy. Connecting all of the pain points was this thread of context. When agents had the right context and right tools to use it, the pain was less.

Context is king, managing it is messy

Context-rot, context-window, context persistence, shared context. Even in successful applications context ends up an amorphous blob of "I don't know what's happening", or "I do know and I'm scared". Associative has this neat feature of connecting the dots between data points automatically. I knew if we could have agents "get" that they'd be able to use the contextualized data in the layer with minimal management. So for agents, we made the virtual layer a context-engine where they can use a small roster of primitive tools to govern themselves and help users out.

We ported the MCP from API wrapper to focused tools: Check existence, verify provenance, get an overview, explore a piece of data, get records, and check connection between different datas. It turns out with these tools even tiny agents ( <4b) were able to become helpful and reliable operators with no system-prompt and no pre-defined schemas or data definitions.

Evolving and growing

Once our features were stable enough to showcase to customers, we began our research preview and live product evolution. My focus is maintained on making that the experience is fundamentally different as well as good. Different is memorable. So as more and more context engines joined the pool, we leaned on what made the underlying offer distinct and better: determinism, vendor agnosticism, and interoperability.

Wasted and Trapped Potential There is an inordinate amount of compute cycles that were being used to manage cascading hierarchies of agents policing and enforcing agent behaviors. It can cut time and force customers into a reliance on your drip-feed. It's wrong though.

The more we lean into the agent-as-infrastructure the less flexible and portable it is for our customers: you need specific models, or harnesses behaving specific ways and often the ones providing that would be us. I hate that: it's anti-consumer and forces dependencies and externally-defined operators inside apps, workflows, systems? I can't ingest data unless it goes through some agent consuming compute at some cost? What if it starts making mistakes or doesn't support a new input type? No thanks. It seemed our builder audience agreed: We achieved over 2000 sign-ups for early access shortly after alerting some early interested parties.

By prioritizing simplicity-to-launch and zero-shot operability, ODE is live updating and evolving alongside the growing user base. I spun-up a demo-hub of sample workflows (agents performing clean-room data ops with anonymous data and hallucination session buddy for grounding, circuit tracing, and just a bundle of cool stuff).

I'm proud of ODE, it embodies several of my core product values: respect the user, solve a meaningful problem, and always have someone in mind when you plan a new feature or product. It also acts as a stepping stone to bringing the primitive of self-organizing data our of bespoke applications, and into widespread cross-domain use.

If you want to check it out, you can see it here