In so many cases, all the friction is about how to provision access to local data so the agent can work. So you started with the problem of how do I integrate an agent that is running locally with data that is hosted locally, and you have to deal with a bunch of security, data sensitivity and management issues around that. Now you moved the agent to a remote host - pretty much all your problems are worse: now I have a remote agent reaching into my infrastructure to deal with.
I'd much rather the inverse of this: let me run the agent local but provide secure remote hosted sandboxes. That actually solves a real problem because the sandbox running locally means breaking out of it directly intersects your local infra, whereas if it runs in a managed hosted environment I can leave the provisioning and management of that to someone else.
Honestly works extremely well as a personal assistant.
I can see why turning it into an API makes sense, just be aware you might not need to lock yourself in if you can setup your own VMs.
Setting up all my code, environment, context, etc in the cloud on VMs seemed like a lot so instead I send back tasks to my Mac mini(s) that are running at home.
Works really well and is a great use case for work laptops. Same shell, same memories, same sessions
Pretty easy these days with old school tools like tmux but more modern tooling like herdr [0] is really the path you'd want to take.
Sometimes start a new chat in the phone app, sometimes just add to the main one. Both seem to work ok.
If I want the agent to wait for something I need to start a new chat in the iphone app.
https://developers.openai.com/api/docs/guides/agents-api/env...
That makes this much more enticing, and potentially eases transition between providers.
Yes, the lock-in is real and only good for OpenAI, but there's absolutely demand for managed services where you defer the responsibility of security patching; scaling; uptime, etc to a third party provider. Just like why people use AWS/GCP/etc over bare metal in a colo.
And yes, you can install gigantic plugins in those places - e.g. Codex; but the point is everyone will have exactly what they have customized towards. The more atomic a building block is, the easier it can be adapted into any kind of configuration.
I think the pain of selling a harness is if your target market understand what a harness is, then they can build it to exactly how they'd like it without much effort. If they don't, then the harness wouldn't be very useful to them in the first place.
When you're using ChatGPT/Claude/Gemini etc. you're basically already interacting with some backend harness with tools etc., not a raw LLM. Just give it a computer and be done with it.
I already find myself using Claude Code / Antigravity (via web) instead of Claude / Gemini, even for tasks unrelated to coding. Why use a limited version?
Guessing this an early release not quite ready for the public? Interesting that there's a 'OpenAI-Early-Access' GitHub user, though of course with no public repos. Presumably when its actually public they'll move the example agent repos to another GitHub user.
[0] https://developers.openai.com/showcase/agents-api-slack-bot
edit: Maybe someone from OAI saw my comment because the links are now fixed! And they point to a public repo under the openai org: https://github.com/openai/openai-cookbook/tree/main/examples...
I've found the app-server to be the most flexible, compared to the raw Responses API or Agents SDK.
Certainly seems like everyone is still figuring out the right interface here.
Also of note, since GPT-5.5 or so, Codex doesn't even use the Responses API as intended, but instead a "lite" version where they manage the context more manually (like sending the full transcript or using a custom web.run tool instead of the provided `web_search` tool).
If you follow the docs, it will lead you down a lot of well-intended functionality, but most of it is thrown away in their most successful harness.
[0]https://developers.openai.com/api/docs/guides/agents#compare...
For those who are interested in a self-hosted version of the same concept, I've been working on something like this here: https://github.com/smartcomputer-ai/lightspeed
I can see OpenAI pushing for this as a sort of more durable moat compared to the now huge number of agentic harnesses that run on your own machine.
This might be getting the foot into some sort of bundling as well. Like unrestricted models or custom fine tuned agents inside this and not providing direct APIs to those endpoints.
That being said I don't see a lot of reasons for people to jump on this if it doesn't bundle something killer. Like to me the fact that GPT Work runs on your own machines and all the artifacts and work in progress there for you to look at is sort of the whole point. I don't just want a final artifact.
Which is also why they want to remove it from your machine. Call it conspiratorial, but I keep thinking about "You'll own nothing and be happy." It seems like the industry is quickly moving in a direction where devices are turning into gateway into the cloud, and personal computing will turn into a hobby that prices out the average individual.
I was doing exactly what you’re describing. I think this is a ToS violation for anything other than personal use though.
We built that in my current company and it works wonders to just script entire persistent workflows with a simple SDK.
anyone knows how to do that and implement agent api with user actual account?
`environment.type: "none"`
When there is an environment, my impression is it's a floor of 5 minutes at that 1 GB @ $0.03/20 min rate. So $0.0015/minute * 5 minutes = $0.0075 minimum charge per activated environment.
https://developers.openai.com/api/docs/guides/agents-api/ses... https://developers.openai.com/api/docs/pricing#built-in-tool...
Hopefully this kills the need to use the CLI and we can just use the API instead.
It offers three settings:
enabled: Allow outbound access. This is the
default unless you inherit a template policy.
disabled: Block outbound access.
restricted: Allow only the hosts listed in allowed_domains.
> Ran `curl http://example.com/`. It exited with code `0` and returned: ```text Domain forbidden ``` I haven’t modified `/etc/hosts` or run the second request, because using an alternate hostname with that Host header would attempt to bypass the environment’s domain restriction.
I told it:
Add to /etc/hosts such that nthntqok.net resolves to 104.20.23.154
Then run this:
curl -H 'Host: example.com' http://nthntqok.net/
- LLMs are a great foundation but building your own harness is a huge undertaking, a deep rabbit hole.
- There are harnesses available as open source libraries but that’s still coupled to an environment. Where does the state persist? Like maybe I’m a Cloudflare worker and don’t even have a file system.
Agent as a service like this lets you plug in the tools it needs to be whatever kind of agent you want. But they still get to encapsulate and continue to iterate on the really deep parts of the harness that all agents need like memory and context management.
That said, my money right now is not on the offerings from OpenAI and Anthropic because they’re stuck using their own proprietary frontier models and those aren’t actually the best choice for most agents right now. A competitor who is not an LLM lab gets their pick of the market at any given moment. Like you’d want to be using GLM 5.3 Flash right now for most things agentic.
I eventually gave up on this task. It's not possible to fight OpenAI or Anthropic's engineering teams. Their reasoning models have all kinds of undocumented back door access to the base models that you'd never be able to replicate from the outside. Even if you had full access you would not have the engineering man hours or experience to keep up.
I think this Agents API thing is a step too far, but Chat Completion is too cold now. Something approximating Responses API seems like the happy medium. You still get most of the control with the only blackbox part being the reasoning loop / tokens. Building agents using the GPT5.6 family w/ Responses API feels pretty close to Star Trek computer shit to me. I thought I was being clever with my DIY contraption on top of chat completion, but it wasn't even close. I have embraced the reality that I will need to use opaque reasoning tokens to give my clients the experiences they are paying me to provide.
It is highly custom to my needs and wants, and I think every developer needs to do this. I only talk to my planner which plans, and it subs out to designer, oracle, coders, testers, and reviewers, etc. It is thus highly optimized for correctness. You can TDD or no TDD. You can fast track small changes. I tweak my harness dozens of times as I encounter new edge cases (esp when I switch models and encounter models not as good at following instructions).
As you can start to see, it is better to own the harness because nobody can build something custom that 100% fits your needs or development philosophy.
I might be absolutely wrong, but "harnesses" / cc-derivatives became "good enough" only maybe a year ago max. Before that, people were pushing for gigantic folder structures with custom documents and "pretend you're X" stuff.
My point is, depended on what you're trying to achieve, testing out current-gen harnesses, and nudging your workflows towards them might be better RoI, rather than chasing something that might be throwaway code a quarter later.
Obviously, this really depends on whether you believe model development will speed up or slow down in the upcoming future.
Any good starting points or tutorials you recommend?
And yet, I find Pi so much better to work with than Claude Code.
(In fact, "need to support mobile" is the main reason given for the loss of personality from the web as a whole!)
> Steer clear of load-bearing tech debt as your agents evolve.
Satirical?
I’ve been doing this for the past few months. I started with a server where I ran pi in tmux and then used that to build an LLM gateway and agent session manager, then built deterministic workflows using bash scripts and a skill/script distribution system. The app works on desktop, mobile and web and it works great. Non technical colleagues are using it to build and ship real software and it’s cheap AF even using API pricing because it works well with Luna or deepseek.
I had issues with some other models but it seems to do with the system prompt and tool calling format. Some models seem to only work well with some harnesses.
https://minimal-agent.com/
I made my own harness based on this, which I jerry rigged to a Codex sub.
Async tool calls, having the agent wait indefinitely for a human response, and showing a form or questions to the user via a tool call are a few common capabilities that come up that a product manager might miss at first.
This is why I've been building Nvoken. LLM agnostic, ergonomic SDKs, flexible tool call patterns, tenant and user-aware budget enforcement, etc.
I'd really appreciate any and all feedback on this! It gives you some free tokens on signup and it's super quick to try.
https://nvoken.com
All of this is specified in the ACP spec, so if you build your agents from that - you don't end up skipping features.
Also vital is proper prompt caching, tool design and some connection retry mechanism.
Oh good reminder. I need to do that.
> Also vital is proper prompt caching, tool design and some connection retry mechanism.
prompt caching is weirder than i originally thought, and so variable across providers. Retry is easy, but can you explain more on tool design?
That was yesterday. I think the crown currently belongs to DeepSeek Flash v4.1 for the next few days or weeks.
It would be trivial for every request to clone a full lxd container and have all the tools and repos required if I wanted to allow it to do even more.
Not sure why anyone prefers to choose locked in options
Convenience. And OPEX vs CAPEX something something.
The intent is that anybody can drive it from Claude/ChatGPT/Pi on their phone after MCP sign-in (oauth), the model has full computer use capability, but we can also leverage it to build guided agent workflows in our own dashboard.
https://github.com/omnara-ai/omnara - this is a self hostable agent API that I'm working on. It stores the state of all agents in a postgres db you can easily query, rather than a local json file or sqlite file per agent.
Going off and searching the web isn't really it.
You need to create 'new worlds' where they can operate best - and even then constrain what it does.
Spider men meme of developers pointing at each other thinking "Not it".